diff --git a/.gitignore b/.gitignore
index c3d85114a5..8f6d4d891c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,5 +31,6 @@ strings.csv
 resources/electron.js
 .clj-kondo/
 .lsp/
-
-.vscode
+/libs/dist/
+charlie/
+.vscode
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index 274db7b4f2..3bb2b915fb 100755
--- a/deps.edn
+++ b/deps.edn
@@ -35,6 +35,7 @@
   expound/expound             {:mvn/version "0.8.6"}
   com.lambdaisland/glogi      {:mvn/version "1.0.116"}
   binaryage/devtools          {:mvn/version "1.0.2"}
+  camel-snake-kebab/camel-snake-kebab {:mvn/version "0.4.2"}
   instaparse/instaparse       {:mvn/version "1.4.10"}
   nubank/workspaces           {:mvn/version "1.1.1"}}
 
diff --git a/libs/.npmignore b/libs/.npmignore
new file mode 100644
index 0000000000..ca4e81e138
--- /dev/null
+++ b/libs/.npmignore
@@ -0,0 +1,2 @@
+src/
+webpack.*
\ No newline at end of file
diff --git a/libs/README.md b/libs/README.md
new file mode 100644
index 0000000000..306fa3e947
--- /dev/null
+++ b/libs/README.md
@@ -0,0 +1,17 @@
+## @logseq/libs
+
+🚀 Logseq SDK libraries [WIP].
+
+#### Installation
+
+```shell
+yarn add @logseq/libs
+```
+
+#### Usage
+
+Load `logseq` plugin sdk as global namespace
+
+```js
+import "@logseq/libs"
+```
\ No newline at end of file
diff --git a/libs/index.d.ts b/libs/index.d.ts
new file mode 100644
index 0000000000..9e6545a5d2
--- /dev/null
+++ b/libs/index.d.ts
@@ -0,0 +1,5 @@
+import { ILSPluginUser } from './dist/LSPlugin'
+
+declare global {
+  var logseq: ILSPluginUser
+}
\ No newline at end of file
diff --git a/libs/package.json b/libs/package.json
new file mode 100644
index 0000000000..f268fe80f3
--- /dev/null
+++ b/libs/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "@logseq/libs",
+  "version": "0.0.1-alpha.17",
+  "description": "Logseq SDK libraries",
+  "main": "dist/lsplugin.user.js",
+  "typings": "index.d.ts",
+  "private": false,
+  "scripts": {
+    "build:user": "webpack --mode production",
+    "dev:user": "npm run build:user -- --mode development --watch",
+    "build:core": "webpack --config webpack.config.core.js --mode production",
+    "dev:core": "npm run build:core -- --mode development --watch",
+    "build": "tsc && rm dist/*.js && npm run build:user"
+  },
+  "dependencies": {
+    "csstype": "^3.0.8",
+    "debug": "^4.3.1",
+    "dompurify": "^2.2.7",
+    "eventemitter3": "^4.0.7",
+    "path": "^0.12.7",
+    "postmate": "^1.5.2",
+    "snake-case": "^3.0.4"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.5",
+    "@types/dompurify": "^2.2.1",
+    "@types/lodash-es": "^4.17.4",
+    "@types/postmate": "^1.5.1",
+    "ts-loader": "^8.0.17",
+    "typescript": "^4.2.2",
+    "webpack": "^5.24.3",
+    "webpack-bundle-analyzer": "^4.4.0",
+    "webpack-cli": "^4.5.0"
+  }
+}
diff --git a/libs/src/LSPlugin.caller.ts b/libs/src/LSPlugin.caller.ts
new file mode 100644
index 0000000000..9afb93fe53
--- /dev/null
+++ b/libs/src/LSPlugin.caller.ts
@@ -0,0 +1,322 @@
+import Postmate from 'postmate'
+import EventEmitter from 'eventemitter3'
+import { PluginLocal } from './LSPlugin.core'
+import Debug from 'debug'
+import { deferred } from './helpers'
+import { LSPluginShadowFrame } from './LSPlugin.shadow'
+
+const debug = Debug('LSPlugin:caller')
+
+type DeferredActor = ReturnType<typeof deferred>
+
+export const FLAG_AWAIT = '#await#response#'
+export const LSPMSG = '#lspmsg#'
+export const LSPMSG_ERROR_TAG = '#lspmsg#error#'
+export const LSPMSG_SETTINGS = '#lspmsg#settings#'
+export const LSPMSG_BEFORE_UNLOAD = '#lspmsg#beforeunload#'
+export const LSPMSG_SYNC = '#lspmsg#reply#'
+export const LSPMSG_READY = '#lspmsg#ready#'
+export const LSPMSGFn = (id: string) => `${LSPMSG}${id}`
+export const AWAIT_LSPMSGFn = (id: string) => `${FLAG_AWAIT}${id}`
+
+/**
+ * Call between core and user
+ */
+class LSPluginCaller extends EventEmitter {
+  private _connected: boolean = false
+
+  private _parent?: Postmate.ParentAPI
+  private _child?: Postmate.ChildAPI
+
+  private _shadow?: LSPluginShadowFrame
+
+  private _status?: 'pending' | 'timeout'
+  private _userModel: any = {}
+
+  private _call?: (type: string, payload: any, actor?: DeferredActor) => Promise<any>
+  private _callUserModel?: (type: string, payload: any) => Promise<any>
+
+  private _debugTag = ''
+
+  constructor (
+    private _pluginLocal: PluginLocal | null
+  ) {
+    super()
+
+    if (_pluginLocal) {
+      this._debugTag = _pluginLocal.debugTag
+    }
+  }
+
+  async connectToChild () {
+    if (this._connected) return
+
+    const { shadow } = this._pluginLocal!
+
+    if (shadow) {
+      await this._setupShadowSandbox()
+    } else {
+      await this._setupIframeSandbox()
+    }
+  }
+
+  async connectToParent (userModel = {}) {
+    if (this._connected) return
+
+    const caller = this
+    const isShadowMode = this._pluginLocal != null
+
+    let syncGCTimer: any = 0
+    let syncTag = 0
+    const syncActors = new Map<number, DeferredActor>()
+    const readyDeferred = deferred(1000 * 5)
+
+    const model: any = this._extendUserModel({
+      [LSPMSG_READY]: async () => {
+        await readyDeferred.resolve()
+      },
+
+      [LSPMSG_BEFORE_UNLOAD]: async (e) => {
+        const actor = deferred(10 * 1000)
+        caller.emit('beforeunload', Object.assign({ actor }, e))
+        await actor.promise
+      },
+
+      [LSPMSG_SETTINGS]: async ({ type, payload }) => {
+        caller.emit('settings:changed', payload)
+      },
+
+      [LSPMSG]: async ({ ns, type, payload }: any) => {
+        debug(`${this._debugTag} [call from host]`, ns, type, payload)
+
+        if (ns && ns.startsWith('hook')) {
+          caller.emit(`${ns}:${type}`, payload)
+          return
+        }
+
+        caller.emit(type, payload)
+      },
+
+      [LSPMSG_SYNC]: ({ _sync, result }: any) => {
+        debug(`sync reply #${_sync}`, result)
+
+        if (syncActors.has(_sync)) {
+          const actor = syncActors.get(_sync)
+
+          if (actor) {
+            if (result?.hasOwnProperty(LSPMSG_ERROR_TAG)) {
+              actor.reject(result[LSPMSG_ERROR_TAG])
+            } else {
+              actor.resolve(result)
+            }
+
+            syncActors.delete(_sync)
+          }
+        }
+      },
+
+      ...userModel
+    })
+
+    if (isShadowMode) {
+      await readyDeferred.promise
+      return JSON.parse(JSON.stringify(this._pluginLocal?.toJSON()))
+    }
+
+    const handshake = new Postmate.Model(model)
+
+    this._status = 'pending'
+
+    await handshake.then(refParent => {
+      this._child = refParent
+      this._connected = true
+
+      this._call = async (type, payload = {}, actor) => {
+        if (actor) {
+          const tag = ++syncTag
+          syncActors.set(tag, actor)
+          payload._sync = tag
+
+          actor.setTag(`async call #${tag}`)
+          debug('async call #', tag)
+        }
+
+        refParent.emit(LSPMSGFn(model.baseInfo.id), { type, payload })
+
+        return actor?.promise as Promise<any>
+      }
+
+      this._callUserModel = async (type, payload) => {
+        try {
+          model[type](payload)
+        } catch (e) {
+          debug(`model method #${type} not existed`)
+        }
+      }
+
+      // actors GC
+      syncGCTimer = setInterval(() => {
+        if (syncActors.size > 100) {
+          for (const [k, v] of syncActors) {
+            if (v.settled) {
+              syncActors.delete(k)
+            }
+          }
+        }
+      }, 1000 * 60 * 30)
+    }).finally(() => {
+      this._status = undefined
+    })
+
+    await readyDeferred.promise
+
+    return model.baseInfo
+  }
+
+  async call (type: any, payload: any = {}) {
+    return this._call?.call(this, type, payload)
+  }
+
+  async callAsync (type: any, payload: any = {}) {
+    const actor = deferred(1000 * 10)
+    return this._call?.call(this, type, payload, actor)
+  }
+
+  async callUserModel (type: string, payload: any = {}) {
+    return this._callUserModel?.call(this, type, payload)
+  }
+
+  async _setupIframeSandbox () {
+    const pl = this._pluginLocal!
+
+    const handshake = new Postmate({
+      container: document.body,
+      url: pl.options.entry!,
+      classListArray: ['lsp-iframe-sandbox'],
+      model: { baseInfo: JSON.parse(JSON.stringify(pl.toJSON())) }
+    })
+
+    this._status = 'pending'
+
+    // timeout for handshake
+    let timer
+
+    return new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`handshake Timeout`))
+      }, 3 * 1000) // 3secs
+
+      handshake.then(refChild => {
+        this._parent = refChild
+        this._connected = true
+        this.emit('connected')
+
+        refChild.frame.setAttribute('id', pl.id)
+        refChild.on(LSPMSGFn(pl.id), ({ type, payload }: any) => {
+          debug(`[call from plugin] `, type, payload)
+
+          this._pluginLocal?.emit(type, payload || {})
+        })
+
+        this._call = async (...args: any) => {
+          // parent all will get message before handshaked
+          await refChild.call(LSPMSGFn(pl.id), { type: args[0], payload: args[1] || {} })
+        }
+
+        this._callUserModel = async (type, payload: any) => {
+          if (type.startsWith(FLAG_AWAIT)) {
+            // TODO: attach payload
+            return await refChild.get(type.replace(FLAG_AWAIT, ''))
+          } else {
+            refChild.call(type, payload)
+          }
+        }
+
+        resolve(null)
+      }).catch(e => {
+        reject(e)
+      }).finally(() => {
+        clearTimeout(timer)
+      })
+    }).catch(e => {
+      debug('iframe sandbox error', e)
+      throw e
+    }).finally(() => {
+      this._status = undefined
+    })
+  }
+
+  async _setupShadowSandbox () {
+    const pl = this._pluginLocal!
+    const shadow = this._shadow = new LSPluginShadowFrame(pl)
+
+    try {
+      this._status = 'pending'
+
+      await shadow.load()
+
+      this._connected = true
+      this.emit('connected')
+
+      this._call = async (type, payload = {}, actor) => {
+        actor && (payload.actor = actor)
+
+        // TODO: support sync call
+        // @ts-ignore Call in same thread
+        this._pluginLocal?.emit(type, payload)
+
+        return actor?.promise
+      }
+
+      this._callUserModel = async (...args: any) => {
+        let type = args[0] as string
+
+        if (type?.startsWith(FLAG_AWAIT)) {
+          type = type.replace(FLAG_AWAIT, '')
+        }
+
+        const payload = args[1] || {}
+        const fn = this._userModel[type]
+
+        if (typeof fn === 'function') {
+          await fn.call(null, payload)
+        }
+      }
+    } catch (e) {
+      debug('shadow sandbox error', e)
+      throw e
+    } finally {
+      this._status = undefined
+    }
+  }
+
+  _extendUserModel (model: any) {
+    return Object.assign(this._userModel, model)
+  }
+
+  _getSandboxIframeContainer () {
+    return this._parent?.frame
+  }
+
+  _getSandboxShadowContainer () {
+    return this._shadow?.frame
+  }
+
+  set debugTag (value: string) {
+    this._debugTag = value
+  }
+
+  async destroy () {
+    if (this._parent) {
+      await this._parent.destroy()
+    }
+
+    if (this._shadow) {
+      this._shadow.destroy()
+    }
+  }
+}
+
+export {
+  LSPluginCaller
+}
diff --git a/libs/src/LSPlugin.core.ts b/libs/src/LSPlugin.core.ts
new file mode 100644
index 0000000000..23cbefd896
--- /dev/null
+++ b/libs/src/LSPlugin.core.ts
@@ -0,0 +1,1023 @@
+import EventEmitter from 'eventemitter3'
+import {
+  deepMerge,
+  setupInjectedStyle,
+  genID,
+  setupInjectedTheme,
+  setupInjectedUI,
+  deferred,
+  invokeHostExportedApi,
+  isObject, withFileProtocol
+} from './helpers'
+import Debug from 'debug'
+import {
+  LSPluginCaller,
+  LSPMSG_READY, LSPMSG_SYNC,
+  LSPMSG, LSPMSG_SETTINGS,
+  LSPMSG_ERROR_TAG, LSPMSG_BEFORE_UNLOAD, AWAIT_LSPMSGFn
+} from './LSPlugin.caller'
+import {
+  ILSPluginThemeManager,
+  LSPluginPkgConfig,
+  StyleOptions,
+  StyleString,
+  ThemeOptions,
+  UIOptions
+} from './LSPlugin'
+import { snakeCase } from 'snake-case'
+import DOMPurify from 'dompurify'
+import * as path from 'path'
+
+const debug = Debug('LSPlugin:core')
+
+declare global {
+  interface Window {
+    LSPluginCore: LSPluginCore
+  }
+}
+
+type DeferredActor = ReturnType<typeof deferred>
+type LSPluginCoreOptions = {
+  localUserConfigRoot: string
+}
+
+/**
+ * User settings
+ */
+class PluginSettings extends EventEmitter<'change'> {
+  private _settings: Record<string, any> = {
+    disabled: false
+  }
+
+  constructor (private _userPluginSettings: any) {
+    super()
+
+    Object.assign(this._settings, _userPluginSettings)
+  }
+
+  get<T = any> (k: string): T {
+    return this._settings[k]
+  }
+
+  set (k: string | Record<string, any>, v?: any) {
+    const o = deepMerge({}, this._settings)
+
+    if (typeof k === 'string') {
+      if (this._settings[k] == v) return
+      this._settings[k] = v
+    } else if (isObject(k)) {
+      deepMerge(this._settings, k)
+    } else {
+      return
+    }
+
+    this.emit('change',
+      Object.assign({}, this._settings), o)
+  }
+
+  toJSON () {
+    return this._settings
+  }
+}
+
+class PluginLogger extends EventEmitter<'change'> {
+  private _logs: Array<[type: string, payload: any]> = []
+
+  constructor (private _tag: string) {
+    super()
+  }
+
+  write (type: string, payload: any[]) {
+    let msg = payload.reduce((ac, it) => {
+      if (it && it instanceof Error) {
+        ac += `${it.message} ${it.stack}`
+      } else {
+        ac += it.toString()
+      }
+      return ac
+    }, `[${this._tag}][${new Date().toLocaleTimeString()}] `)
+
+    this._logs.push([type, msg])
+    this.emit('change')
+  }
+
+  clear () {
+    this._logs = []
+    this.emit('change')
+  }
+
+  info (...args: any[]) {
+    this.write('INFO', args)
+  }
+
+  error (...args: any[]) {
+    this.write('ERROR', args)
+  }
+
+  warn (...args: any[]) {
+    this.write('WARN', args)
+  }
+
+  toJSON () {
+    return this._logs
+  }
+}
+
+type UserPreferences = {
+  theme: ThemeOptions
+  externals: Array<string> // external plugin locations
+
+  [key: string]: any
+}
+
+type PluginLocalOptions = {
+  key?: string // Unique from Logseq Plugin Store
+  entry: string // Plugin main file
+  url: string // Plugin package fs location
+  name: string
+  version: string
+  mode: 'shadow' | 'iframe'
+  settings?: PluginSettings
+  logger?: PluginLogger
+
+  [key: string]: any
+}
+
+type PluginLocalUrl = Pick<PluginLocalOptions, 'url'> & { [key: string]: any }
+type RegisterPluginOpts = PluginLocalOptions | PluginLocalUrl
+
+type PluginLocalIdentity = string
+
+enum PluginLocalLoadStatus {
+  LOADING = 'loading',
+  UNLOADING = 'unloading',
+  LOADED = 'loaded',
+  UNLOADED = 'unload',
+  ERROR = 'error'
+}
+
+function initUserSettingsHandlers (pluginLocal: PluginLocal) {
+  const _ = (label: string): any => `settings:${label}`
+
+  pluginLocal.on(_('update'), (attrs) => {
+    if (!attrs) return
+    pluginLocal.settings?.set(attrs)
+  })
+}
+
+function initMainUIHandlers (pluginLocal: PluginLocal) {
+  const _ = (label: string): any => `main-ui:${label}`
+
+  pluginLocal.on(_('visible'), ({ visible, toggle, cursor }) => {
+    const el = pluginLocal.getMainUI()
+    el?.classList[toggle ? 'toggle' : (visible ? 'add' : 'remove')]('visible')
+    // pluginLocal.caller!.callUserModel(LSPMSG, { type: _('visible'), payload: visible })
+    // auto focus frame
+    if (visible) {
+      if (!pluginLocal.shadow && el) {
+        (el as HTMLIFrameElement).contentWindow?.focus()
+      }
+    }
+
+    if (cursor) {
+      invokeHostExportedApi('restore_editing_cursor')
+    }
+  })
+
+  pluginLocal.on(_('attrs'), (attrs: Record<string, any>) => {
+    const el = pluginLocal.getMainUI()
+    Object.entries(attrs).forEach(([k, v]) => {
+      el?.setAttribute(k, v)
+    })
+  })
+
+  pluginLocal.on(_('style'), (style: Record<string, any>) => {
+    const el = pluginLocal.getMainUI()
+    Object.entries(style).forEach(([k, v]) => {
+      el!.style[k] = v
+    })
+  })
+}
+
+function initProviderHandlers (pluginLocal: PluginLocal) {
+  let _ = (label: string): any => `provider:${label}`
+  let themed = false
+
+  pluginLocal.on(_('theme'), (theme: ThemeOptions) => {
+    pluginLocal.themeMgr.registerTheme(
+      pluginLocal.id,
+      theme
+    )
+
+    if (!themed) {
+      pluginLocal._dispose(() => {
+        pluginLocal.themeMgr.unregisterTheme(pluginLocal.id)
+      })
+
+      themed = true
+    }
+  })
+
+  pluginLocal.on(_('style'), (style: StyleString | StyleOptions) => {
+    let key: string | undefined
+
+    if (typeof style !== 'string') {
+      key = style.key
+      style = style.style
+    }
+
+    if (!style || !style.trim()) return
+
+    pluginLocal._dispose(
+      setupInjectedStyle(style, {
+        'data-injected-style': key ? `${key}-${pluginLocal.id}` : '',
+        'data-ref': pluginLocal.id
+      })
+    )
+  })
+
+  pluginLocal.on(_('ui'), (ui: UIOptions) => {
+    pluginLocal._onHostMounted(() => {
+      // safe template
+      ui.template = DOMPurify.sanitize(ui.template)
+
+      pluginLocal._dispose(
+        setupInjectedUI.call(pluginLocal,
+          ui, {
+            'data-ref': pluginLocal.id
+          })
+      )
+    })
+  })
+}
+
+function initApiProxyHandlers (pluginLocal: PluginLocal) {
+  let _ = (label: string): any => `api:${label}`
+
+  pluginLocal.on(_('call'), async (payload) => {
+    let ret: any
+
+    try {
+      ret = await invokeHostExportedApi(payload.method, ...payload.args)
+    } catch (e) {
+      ret = {
+        [LSPMSG_ERROR_TAG]: e,
+      }
+    }
+
+    const { _sync } = payload
+
+    if (pluginLocal.shadow) {
+      if (payload.actor) {
+        payload.actor.resolve(ret)
+      }
+      return
+    }
+
+    if (_sync != null) {
+      const reply = (result: any) => {
+        pluginLocal.caller?.callUserModel(LSPMSG_SYNC, {
+          result, _sync
+        })
+      }
+
+      Promise.resolve(ret).then(reply, reply)
+    }
+  })
+}
+
+class IllegalPluginPackageError extends Error {
+  constructor (message: string) {
+    super(message)
+    this.name = IllegalPluginPackageError.name
+  }
+}
+
+class ExistedImportedPluginPackageError extends Error {
+  constructor (message: string) {
+    super(message)
+    this.name = ExistedImportedPluginPackageError.name
+  }
+}
+
+/**
+ * Host plugin for local
+ */
+class PluginLocal
+  extends EventEmitter<'loaded' | 'unloaded' | 'beforeunload' | 'error'> {
+
+  private _disposes: Array<() => Promise<any>> = []
+  private _id: PluginLocalIdentity
+  private _status: PluginLocalLoadStatus = PluginLocalLoadStatus.UNLOADED
+  private _loadErr?: Error
+  private _localRoot?: string
+  private _userSettingsFile?: string
+  private _caller?: LSPluginCaller
+
+  /**
+   * @param _options
+   * @param _themeMgr
+   * @param _ctx
+   */
+  constructor (
+    private _options: PluginLocalOptions,
+    private _themeMgr: ILSPluginThemeManager,
+    private _ctx: LSPluginCore
+  ) {
+    super()
+
+    this._id = _options.key || genID()
+
+    initUserSettingsHandlers(this)
+    initMainUIHandlers(this)
+    initProviderHandlers(this)
+    initApiProxyHandlers(this)
+  }
+
+  async _setupUserSettings () {
+    const { _options } = this
+    const key = _options.name.replace(/[^a-z0-9]/gi, '_').toLowerCase() + '_' + this.id
+    const logger = _options.logger = new PluginLogger('Loader')
+
+    try {
+      const [userSettingsFilePath, userSettings] = await invokeHostExportedApi('load_plugin_user_settings', key)
+      this._userSettingsFile = userSettingsFilePath
+
+      const settings = _options.settings = new PluginSettings(userSettings)
+
+      // observe settings
+      settings.on('change', (a, b) => {
+        debug('linked settings change', a)
+
+        if (!a.disabled && b.disabled) {
+          // Enable plugin
+          this.load()
+        }
+
+        if (a.disabled && !b.disabled) {
+          // Disable plugin
+          this.unload()
+        }
+
+        if (a) {
+          invokeHostExportedApi(`save_plugin_user_settings`, key, a)
+        }
+      })
+    } catch (e) {
+      debug('[load plugin user settings Error]', e)
+      logger?.error(e)
+    }
+  }
+
+  getMainUI (): HTMLElement | undefined {
+    if (this.shadow) {
+      return this.caller?._getSandboxShadowContainer()
+    }
+
+    return this.caller?._getSandboxIframeContainer()
+  }
+
+  async _preparePackageConfigs () {
+    const { url } = this._options
+    let pkg: any
+
+    try {
+      if (!url) {
+        throw new Error('Can not resolve package config location')
+      }
+
+      debug('prepare package root', url)
+
+      pkg = await invokeHostExportedApi('load_plugin_config', url)
+
+      if (!pkg || (pkg = JSON.parse(pkg), !pkg)) {
+        throw new Error(`Parse package config error #${url}/package.json`)
+      }
+    } catch (e) {
+      throw new IllegalPluginPackageError(e.message)
+    }
+
+    // Pick legal attrs
+    ['name', 'author', 'repository', 'version', 'description'].forEach(k => {
+      this._options[k] = pkg[k]
+    })
+
+    // TODO: How with local protocol
+    const localRoot = this._localRoot = url
+    const logseq: Partial<LSPluginPkgConfig> = pkg.logseq || {}
+    const makeFullUrl = (loc, useFileProtocol = false) => {
+      if (!loc) return
+      const reg = /^(http|file|assets)/
+      if (!reg.test(loc)) {
+        const url = path.join(localRoot, loc)
+        loc = reg.test(url) ? url : ('file://' + url)
+      }
+      return useFileProtocol ? loc : loc.replace('file:', 'assets:')
+    }
+    const validateMain = (main) => main && /\.(js|html)$/.test(main)
+
+    // Entry from main
+    if (validateMain(pkg.main)) {
+      this._options.entry = makeFullUrl(pkg.main, true)
+
+      if (logseq.mode) {
+        this._options.mode = logseq.mode
+      }
+    }
+
+    const icon = logseq.icon || pkg.icon
+
+    if (icon) {
+      this._options.icon = makeFullUrl(icon)
+    }
+
+    // TODO: strategy for Logseq plugins center
+    if (logseq.id) {
+      this._id = logseq.id
+    } else {
+      logseq.id = this.id
+      try {
+        await invokeHostExportedApi('save_plugin_config', url, { ...pkg, logseq })
+      } catch (e) {
+        debug('[save plugin ID Error] ', e)
+      }
+    }
+
+    // Validate id
+    const { registeredPlugins, isRegistering } = this._ctx
+    if (isRegistering && registeredPlugins.has(logseq.id)) {
+      throw new ExistedImportedPluginPackageError('prepare package Error')
+    }
+
+    return async () => {
+      try {
+        // 0. Install Themes
+        let themes = logseq.themes
+
+        if (themes) {
+          await this._loadConfigThemes(
+            Array.isArray(themes) ? themes : [themes]
+          )
+        }
+      } catch (e) {
+        debug('[prepare package effect Error]', e)
+      }
+    }
+  }
+
+  async _tryToNormalizeEntry () {
+    let { entry, settings } = this.options
+    let devEntry = settings?.get('_devEntry')
+
+    if (devEntry) {
+      this._options.entry = devEntry
+      return
+    }
+
+    if (!entry.endsWith('.js')) return
+
+    let sdkPath = await invokeHostExportedApi('_callApplication', 'getAppPath')
+    let entryPath = await invokeHostExportedApi(
+      'write_user_tmp_file',
+      `${this._id}_index.html`,
+      `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>logseq plugin entry</title>
+    <script src="${sdkPath}/js/lsplugin.user.js"></script>
+  </head>
+  <body>
+  <div id="app"></div>
+  <script src="${entry}"></script>
+  </body>
+</html>`)
+
+    this._options.entry = withFileProtocol(entryPath)
+  }
+
+  async _loadConfigThemes (themes: Array<ThemeOptions>) {
+    themes.forEach((options) => {
+      if (!options.url) return
+
+      if (!options.url.startsWith('http') && this._localRoot) {
+        options.url = path.join(this._localRoot, options.url)
+        // file:// for native
+        if (!options.url.startsWith('file:')) {
+          options.url = 'assets://' + options.url
+        }
+      }
+
+      // @ts-ignore
+      this.emit('provider:theme', options)
+    })
+  }
+
+  async load (readyIndicator?: DeferredActor) {
+    if (this.pending) {
+      return
+    }
+
+    this._status = PluginLocalLoadStatus.LOADING
+    this._loadErr = undefined
+
+    try {
+      let installPackageThemes: () => Promise<void> = () => Promise.resolve()
+
+      if (!this.options.entry) { // Themes package no entry field
+        installPackageThemes = await this._preparePackageConfigs()
+      }
+
+      if (!this.settings) {
+        await this._setupUserSettings()
+      }
+
+      if (!this.disabled) {
+        await installPackageThemes.call(null)
+      }
+
+      if (this.disabled || !this.options.entry) {
+        return
+      }
+
+      await this._tryToNormalizeEntry()
+
+      this._caller = new LSPluginCaller(this)
+      await this._caller.connectToChild()
+
+      const readyFn = () => {
+        this._caller?.callUserModel(LSPMSG_READY)
+      }
+
+      if (readyIndicator) {
+        readyIndicator.promise.then(readyFn)
+      } else {
+        readyFn()
+      }
+
+      this._disposes.push(async () => {
+        await this._caller?.destroy()
+      })
+    } catch (e) {
+      debug('[Load Plugin Error] ', e)
+      this.logger?.error(e)
+
+      this._status = PluginLocalLoadStatus.ERROR
+      this._loadErr = e
+    } finally {
+      if (!this._loadErr) {
+        this._status = PluginLocalLoadStatus.LOADED
+      }
+    }
+  }
+
+  async reload () {
+    debug('TODO: reload plugin', this.id)
+  }
+
+  /**
+   * @param unregister If true delete plugin files
+   */
+  async unload (unregister: boolean = false) {
+    if (this.pending) {
+      return
+    }
+
+    if (unregister) {
+      await this.unload()
+
+      if (this.isInstalledInUserRoot) {
+        debug('TODO: remove plugin local files from user home root :)')
+      }
+
+      return
+    }
+
+    try {
+      this._status = PluginLocalLoadStatus.UNLOADING
+
+      const eventBeforeUnload = { unregister }
+
+      // sync call
+      try {
+        await this._caller?.callUserModel(AWAIT_LSPMSGFn(LSPMSG_BEFORE_UNLOAD), eventBeforeUnload)
+        this.emit('beforeunload', eventBeforeUnload)
+      } catch (e) {
+        console.error('[beforeunload Error]', e)
+      }
+
+      await this.dispose()
+
+      this.emit('unloaded')
+    } catch (e) {
+      debug('[plugin unload Error]', e)
+    } finally {
+      this._status = PluginLocalLoadStatus.UNLOADED
+    }
+  }
+
+  private async dispose () {
+    for (const fn of this._disposes) {
+      try {
+        fn && (await fn())
+      } catch (e) {
+        console.error(this.debugTag, 'dispose Error', e)
+      }
+    }
+
+    // clear
+    this._disposes = []
+  }
+
+  _dispose (fn: any) {
+    if (!fn) return
+    this._disposes.push(fn)
+  }
+
+  _onHostMounted (callback: () => void) {
+    const actor = this._ctx.hostMountedActor
+
+    if (!actor || actor.settled) {
+      callback()
+    } else {
+      actor?.promise.then(callback)
+    }
+  }
+
+  get isInstalledInUserRoot () {
+    const userRoot = this._ctx.options.localUserConfigRoot
+    const plugRoot = this._localRoot
+    return userRoot && plugRoot && plugRoot.startsWith(userRoot)
+  }
+
+  get loaded () {
+    return this._status === PluginLocalLoadStatus.LOADED
+  }
+
+  get pending () {
+    return [PluginLocalLoadStatus.LOADING, PluginLocalLoadStatus.UNLOADING]
+      .includes(this._status)
+  }
+
+  get status (): PluginLocalLoadStatus {
+    return this._status
+  }
+
+  get settings () {
+    return this.options.settings
+  }
+
+  get logger () {
+    return this.options.logger
+  }
+
+  get disabled () {
+    return this.settings?.get('disabled')
+  }
+
+  get caller () {
+    return this._caller
+  }
+
+  get id (): string {
+    return this._id
+  }
+
+  get shadow (): boolean {
+    return this.options.mode === 'shadow'
+  }
+
+  get options (): PluginLocalOptions {
+    return this._options
+  }
+
+  get themeMgr (): ILSPluginThemeManager {
+    return this._themeMgr
+  }
+
+  get debugTag () {
+    const name = this._options?.name
+    return `#${this._id} ${name ?? ''}`
+  }
+
+  get localRoot (): string {
+    return this._localRoot || this._options.url
+  }
+
+  get loadErr (): Error | undefined {
+    return this._loadErr
+  }
+
+  get userSettingsFile (): string | undefined {
+    return this._userSettingsFile
+  }
+
+  toJSON () {
+    const json = { ...this.options } as any
+    json.id = this.id
+    json.err = this.loadErr
+    json.usf = this.userSettingsFile
+    return json
+  }
+}
+
+/**
+ * Host plugin core
+ */
+class LSPluginCore
+  extends EventEmitter<'beforeenable' | 'enabled' | 'beforedisable' | 'disabled' | 'registered' | 'error' | 'unregistered' |
+    'theme-changed' | 'theme-selected' | 'settings-changed'>
+  implements ILSPluginThemeManager {
+
+  private _isRegistering = false
+  private _readyIndicator?: DeferredActor
+  private _hostMountedActor: DeferredActor = deferred()
+  private _userPreferences: Partial<UserPreferences> = {}
+  private _registeredThemes = new Map<PluginLocalIdentity, Array<ThemeOptions>>()
+  private _registeredPlugins = new Map<PluginLocalIdentity, PluginLocal>()
+
+  /**
+   * @param _options
+   */
+  constructor (private _options: Partial<LSPluginCoreOptions>) {
+    super()
+  }
+
+  async loadUserPreferences () {
+    try {
+      const settings = await invokeHostExportedApi(`load_user_preferences`)
+
+      if (settings) {
+        Object.assign(this._userPreferences, settings)
+      }
+    } catch (e) {
+      debug('[load user preferences Error]', e)
+    }
+  }
+
+  async saveUserPreferences (settings: Partial<UserPreferences>) {
+    try {
+      if (settings) {
+        Object.assign(this._userPreferences, settings)
+      }
+
+      await invokeHostExportedApi(`save_user_preferences`, this._userPreferences)
+    } catch (e) {
+      debug('[save user preferences Error]', e)
+    }
+  }
+
+  async activateUserPreferences () {
+    const { theme } = this._userPreferences
+
+    // 0. theme
+    if (theme) {
+      await this.selectTheme(theme, false)
+    }
+  }
+
+  /**
+   * @param plugins
+   * @param initial
+   */
+  async register (
+    plugins: Array<RegisterPluginOpts> | RegisterPluginOpts,
+    initial = false
+  ) {
+    if (!Array.isArray(plugins)) {
+      await this.register([plugins])
+      return
+    }
+
+    try {
+      this._isRegistering = true
+
+      const userConfigRoot = this._options.localUserConfigRoot
+      const readyIndicator = this._readyIndicator = deferred()
+
+      await this.loadUserPreferences()
+
+      const externals = new Set(this._userPreferences.externals || [])
+
+      if (initial) {
+        plugins = plugins.concat([...externals].filter(url => {
+          return !plugins.length || (plugins as RegisterPluginOpts[]).every((p) => !p.entry && (p.url !== url))
+        }).map(url => ({ url })))
+      }
+
+      for (const pluginOptions of plugins) {
+        const { url } = pluginOptions as PluginLocalOptions
+        const pluginLocal = new PluginLocal(pluginOptions as PluginLocalOptions, this, this)
+
+        const timeLabel = `[LOAD Plugin] ${pluginLocal.debugTag}`
+        console.time(timeLabel)
+
+        await pluginLocal.load(readyIndicator)
+
+        const { loadErr } = pluginLocal
+
+        if (loadErr) {
+          debug(`[Failed LOAD Plugin] #`, pluginOptions)
+
+          this.emit('error', loadErr)
+
+          if (
+            loadErr instanceof IllegalPluginPackageError ||
+            loadErr instanceof ExistedImportedPluginPackageError) {
+            // TODO: notify global log system?
+            continue
+          }
+        }
+
+        console.timeEnd(timeLabel)
+
+        pluginLocal.settings?.on('change', (a) => {
+          this.emit('settings-changed', pluginLocal.id, a)
+          pluginLocal.caller?.callUserModel(LSPMSG_SETTINGS, { payload: a })
+        })
+
+        this._registeredPlugins.set(pluginLocal.id, pluginLocal)
+        this.emit('registered', pluginLocal)
+
+        // external plugins
+        if (!pluginLocal.isInstalledInUserRoot) {
+          externals.add(url)
+        }
+      }
+
+      await this.saveUserPreferences({ externals: Array.from(externals) })
+      await this.activateUserPreferences()
+
+      readyIndicator.resolve('ready')
+    } catch (e) {
+      console.error(e)
+    } finally {
+      this._isRegistering = false
+    }
+  }
+
+  async reload (plugins: Array<PluginLocalIdentity> | PluginLocalIdentity) {
+    if (!Array.isArray(plugins)) {
+      await this.reload([plugins])
+      return
+    }
+
+    for (const identity of plugins) {
+      const p = this.ensurePlugin(identity)
+      await p.reload()
+    }
+  }
+
+  async unregister (plugins: Array<PluginLocalIdentity> | PluginLocalIdentity) {
+    if (!Array.isArray(plugins)) {
+      await this.unregister([plugins])
+      return
+    }
+
+    const unregisteredExternals: Array<string> = []
+
+    for (const identity of plugins) {
+      const p = this.ensurePlugin(identity)
+
+      if (!p.isInstalledInUserRoot) {
+        unregisteredExternals.push(p.options.url)
+      }
+
+      await p.unload(true)
+
+      this._registeredPlugins.delete(identity)
+      this.emit('unregistered', identity)
+    }
+
+    let externals = this._userPreferences.externals || []
+    if (externals.length && unregisteredExternals.length) {
+      await this.saveUserPreferences({
+        externals: externals.filter((it) => {
+          return !unregisteredExternals.includes(it)
+        })
+      })
+    }
+  }
+
+  async enable (plugin: PluginLocalIdentity) {
+    const p = this.ensurePlugin(plugin)
+    if (p.pending) return
+
+    this.emit('beforeenable')
+    p.settings?.set('disabled', false)
+    // this.emit('enabled', p)
+  }
+
+  async disable (plugin: PluginLocalIdentity) {
+    const p = this.ensurePlugin(plugin)
+    if (p.pending) return
+
+    this.emit('beforedisable')
+    p.settings?.set('disabled', true)
+    // this.emit('disabled', p)
+  }
+
+  async _hook (ns: string, type: string, payload?: any, pid?: string) {
+    for (const [_, p] of this._registeredPlugins) {
+      if (!pid || pid === p.id) {
+        p.caller?.callUserModel(LSPMSG, {
+          ns, type: snakeCase(type), payload
+        })
+      }
+    }
+  }
+
+  hookApp (type: string, payload?: any, pid?: string) {
+    this._hook(`hook:app`, type, payload, pid)
+  }
+
+  hookEditor (type: string, payload?: any, pid?: string) {
+    this._hook(`hook:editor`, type, payload, pid)
+  }
+
+  _execDirective (tag: string, ...params: any[]) {
+
+  }
+
+  ensurePlugin (plugin: PluginLocalIdentity | PluginLocal) {
+    if (plugin instanceof PluginLocal) {
+      return plugin
+    }
+
+    const p = this._registeredPlugins.get(plugin)
+
+    if (!p) {
+      throw new Error(`plugin #${plugin} not existed.`)
+    }
+
+    return p
+  }
+
+  hostMounted () {
+    this._hostMountedActor.resolve()
+  }
+
+  get registeredPlugins (): Map<PluginLocalIdentity, PluginLocal> {
+    return this._registeredPlugins
+  }
+
+  get options () {
+    return this._options
+  }
+
+  get readyIndicator (): DeferredActor | undefined {
+    return this._readyIndicator
+  }
+
+  get hostMountedActor (): DeferredActor {
+    return this._hostMountedActor
+  }
+
+  get isRegistering (): boolean {
+    return this._isRegistering
+  }
+
+  get themes (): Map<PluginLocalIdentity, Array<ThemeOptions>> {
+    return this._registeredThemes
+  }
+
+  async registerTheme (id: PluginLocalIdentity, opt: ThemeOptions): Promise<void> {
+    debug('registered Theme #', id, opt)
+
+    if (!id) return
+    let themes: Array<ThemeOptions> = this._registeredThemes.get(id)!
+    if (!themes) {
+      this._registeredThemes.set(id, themes = [])
+    }
+
+    themes.push(opt)
+    this.emit('theme-changed', this.themes, { id, ...opt })
+  }
+
+  async selectTheme (opt?: ThemeOptions, effect = true): Promise<void> {
+    setupInjectedTheme(opt?.url)
+    this.emit('theme-selected', opt)
+    effect && this.saveUserPreferences({ theme: opt })
+  }
+
+  async unregisterTheme (id: PluginLocalIdentity): Promise<void> {
+    debug('unregistered Theme #', id)
+
+    if (!this._registeredThemes.has(id)) return
+    this._registeredThemes.delete(id)
+    this.emit('theme-changed', this.themes, { id })
+  }
+}
+
+function setupPluginCore (options: any) {
+  const pluginCore = new LSPluginCore(options)
+
+  debug('=== 🔗 Setup Logseq Plugin System 🔗 ===')
+
+  window.LSPluginCore = pluginCore
+}
+
+export {
+  PluginLocal,
+  setupPluginCore
+}
diff --git a/libs/src/LSPlugin.shadow.ts b/libs/src/LSPlugin.shadow.ts
new file mode 100644
index 0000000000..2a6cd5bdb3
--- /dev/null
+++ b/libs/src/LSPlugin.shadow.ts
@@ -0,0 +1,116 @@
+import EventEmitter from 'eventemitter3'
+import { PluginLocal } from './LSPlugin.core'
+import { LSPluginUser } from './LSPlugin.user'
+
+// @ts-ignore
+const { importHTML, createSandboxContainer } = window.QSandbox || {}
+
+function userFetch (url, opts) {
+  if (!url.startsWith('http')) {
+    url = url.replace('file://', '')
+    return new Promise(async (resolve, reject) => {
+      try {
+        const content = await window.apis.doAction(['readFile', url])
+        resolve({
+          text () {
+            return content
+          }
+        })
+      } catch (e) {
+        console.error(e)
+        reject(e)
+      }
+    })
+  }
+
+  return fetch(url, opts)
+}
+
+class LSPluginShadowFrame extends EventEmitter<'mounted' | 'unmounted'> {
+  private _frame?: HTMLElement
+  private _root?: ShadowRoot
+  private _loaded = false
+  private _unmountFns: Array<() => Promise<void>> = []
+
+  constructor (
+    private _pluginLocal: PluginLocal
+  ) {
+    super()
+
+    _pluginLocal._dispose(() => {
+      this._unmount()
+    })
+  }
+
+  async load () {
+    const { name, entry } = this._pluginLocal.options
+
+    if (this.loaded || !entry) return
+
+    const { template, execScripts } = await importHTML(entry, { fetch: userFetch })
+
+    this._mount(template, document.body)
+
+    const sandbox = createSandboxContainer(
+      name, {
+        elementGetter: () => this._root?.firstChild,
+      }
+    )
+
+    const global = sandbox.instance.proxy as any
+
+    global.__shadow_mode__ = true
+    global.LSPluginLocal = this._pluginLocal
+    global.LSPluginShadow = this
+    global.LSPluginUser = global.logseq = new LSPluginUser(
+      this._pluginLocal.toJSON() as any,
+      this._pluginLocal.caller!
+    )
+
+    // TODO: {mount, unmount}
+    const execResult: any = await execScripts(global, true)
+
+    this._unmountFns.push(execResult.unmount)
+
+    this._loaded = true
+  }
+
+  _mount (content: string, container: HTMLElement) {
+    const frame = this._frame = document.createElement('div')
+    frame.classList.add('lsp-shadow-sandbox')
+    frame.id = this._pluginLocal.id
+
+    this._root = frame.attachShadow({ mode: 'open' })
+    this._root.innerHTML = `<div>${content}</div>`
+
+    container.appendChild(frame)
+
+    this.emit('mounted')
+  }
+
+  _unmount () {
+    for (const fn of this._unmountFns) {
+      fn && fn.call(null)
+    }
+  }
+
+  destroy () {
+    this.frame?.parentNode?.removeChild(this.frame)
+  }
+
+  get loaded (): boolean {
+    return this._loaded
+  }
+
+  get document () {
+    return this._root?.firstChild as HTMLElement
+  }
+
+  get frame (): HTMLElement {
+    return this._frame!
+  }
+}
+
+export {
+  LSPluginShadowFrame
+}
diff --git a/libs/src/LSPlugin.ts b/libs/src/LSPlugin.ts
new file mode 100644
index 0000000000..60c317997a
--- /dev/null
+++ b/libs/src/LSPlugin.ts
@@ -0,0 +1,429 @@
+import EventEmitter from 'eventemitter3'
+import * as CSS from 'csstype'
+import { LSPluginCaller } from './LSPlugin.caller'
+
+export type PluginLocalIdentity = string
+
+export type ThemeOptions = {
+  name: string
+  url: string
+  description?: string
+  mode?: 'dark' | 'light'
+
+  [key: string]: any
+}
+
+export type StyleString = string;
+export type StyleOptions = {
+  key?: string
+  style: StyleString
+}
+
+export type UIBaseOptions = {
+  key?: string
+  replace?: boolean
+  template: string
+}
+
+export type UIPathIdentity = {
+  /**
+   * DOM selector
+   */
+  path: string
+}
+
+export type UISlotIdentity = {
+  /**
+   * Slot key
+   */
+  slot: string
+}
+
+export type UISlotOptions = UIBaseOptions & UISlotIdentity
+
+export type UIPathOptions = UIBaseOptions & UIPathIdentity
+
+export type UIOptions = UIPathOptions | UISlotOptions
+
+export interface LSPluginPkgConfig {
+  id: PluginLocalIdentity
+  mode: 'shadow' | 'iframe'
+  themes: Array<ThemeOptions>
+  icon: string
+}
+
+export interface LSPluginBaseInfo {
+  id: string // should be unique
+  mode: 'shadow' | 'iframe'
+
+  settings: {
+    disabled: boolean
+    [key: string]: any
+  },
+
+  [key: string]: any
+}
+
+export type IHookEvent = {
+  [key: string]: any
+}
+
+export type IUserOffHook = () => void
+export type IUserHook<E = any, R = IUserOffHook> = (callback: (e: IHookEvent & E) => void) => IUserOffHook
+export type IUserSlotHook<E = any> = (callback: (e: IHookEvent & UISlotIdentity & E) => void) => void
+
+export type BlockID = number
+export type BlockUUID = string
+export type BlockUUIDTuple = ['uuid', BlockUUID]
+
+export type IEntityID = { id: BlockID }
+export type IBatchBlock = { content: string, properties?: Record<string, any>, children?: Array<IBatchBlock> }
+
+export interface AppUserInfo {
+  [key: string]: any
+}
+
+/**
+ * User's app configurations
+ */
+export interface AppUserConfigs {
+  preferredThemeMode: 'dark' | 'light'
+  preferredFormat: 'markdown' | 'org'
+  preferredLanguage: string
+  preferredWorkflow: string
+
+  [key: string]: any
+}
+
+export interface AppGraphInfo {
+  name: string
+  url: string
+  path: string
+
+  [key: string]: any
+}
+
+/**
+ * Block - Logseq's fundamental data structure.
+ */
+export interface BlockEntity {
+  id: BlockID // db id
+  uuid: BlockUUID
+  left: IEntityID
+  format: 'markdown' | 'org'
+  parent: IEntityID
+  unordered: boolean
+  content: string
+  page: IEntityID
+
+  // optional fields in dummy page
+  anchor?: string
+  body?: any
+  children?: Array<BlockEntity | BlockUUIDTuple>
+  container?: string
+  file?: IEntityID
+  level?: number
+  meta?: { timestamps: any, properties: any, startPos: number, endPos: number }
+  title?: Array<any>
+
+  [key: string]: any
+}
+
+/**
+ * Page is just a block with some specific properties.
+ */
+export interface PageEntity {
+  id: BlockID
+  uuid: BlockUUID
+  name: string
+  originalName: string
+  'journal?': boolean
+
+  file?: IEntityID
+  format?: 'markdown' | 'org'
+  journalDay?: number
+}
+
+export type BlockIdentity = BlockUUID | Pick<BlockEntity, 'uuid'>
+export type BlockPageName = string
+export type PageIdentity = BlockPageName | BlockIdentity
+export type SlashCommandActionCmd =
+  'editor/input'
+  | 'editor/hook'
+  | 'editor/clear-current-slash'
+  | 'editor/restore-saved-cursor'
+export type SlashCommandAction = [cmd: SlashCommandActionCmd, ...args: any]
+export type BlockCommandCallback = (e: IHookEvent & { uuid: BlockUUID }) => Promise<void>
+export type BlockCursorPosition = { left: number, top: number, height: number, pos: number, rect: DOMRect }
+
+/**
+ * App level APIs
+ */
+export interface IAppProxy {
+  getUserInfo: () => Promise<AppUserInfo | null>
+
+  getUserConfigs: () => Promise<AppUserConfigs>
+
+  // native
+  relaunch: () => Promise<void>
+  quit: () => Promise<void>
+
+  // graph
+  getCurrentGraph: () => Promise<AppGraphInfo | null>
+
+  // router
+  pushState: (k: string, params?: {}) => void
+  replaceState: (k: string, params?: {}) => void
+
+  // ui
+  showMsg: (content: string, status?: 'success' | 'warning' | string) => void
+  setZoomFactor: (factor: number) => void
+
+  // events
+  onCurrentGraphChanged: IUserHook
+  onThemeModeChanged: IUserHook<{ mode: 'dark' | 'light' }>
+  onBlockRendererSlotted: IUserSlotHook<{ uuid: BlockUUID }>
+  onPageHeadActionsSlotted: IUserSlotHook
+  onRouteChanged: IUserHook<{ path: string, template: string }>
+  onSidebarVisibleChanged: IUserHook<{ visible: boolean }>
+}
+
+/**
+ * Editor related APIs
+ */
+export interface IEditorProxy extends Record<string, any> {
+  /**
+   * register a custom command which will be added to the Logseq slash command list
+   *
+   * @param tag - displayed name of command
+   * @param action - can be a single callback function to run when the command is called, or an array of fixed commands with arguments
+   *
+   * @example
+   * ```ts
+   * logseq.Editor.registerSlashCommand("Say Hi", () => {
+   *   console.log('Hi!')
+   * })
+   * ```
+   *
+   * @example
+   * ```ts
+   * logseq.Editor.registerSlashCommand("💥 Big Bang", [
+   *   ["editor/hook", "customCallback"],
+   *   ["editor/clear-current-slash"],
+   * ]);
+   * ```
+   */
+  registerSlashCommand: (
+    tag: string,
+    action: BlockCommandCallback | Array<SlashCommandAction>
+  ) => boolean
+
+  /**
+   * register a custom command in the block context menu (triggered by right clicking the block dot)
+   * @param tag - displayed name of command
+   * @param action - can be a single callback function to run when the command is called
+   */
+  registerBlockContextMenu: (
+    tag: string,
+    action: BlockCommandCallback
+  ) => boolean
+
+  // block related APIs
+
+  checkEditing: () => Promise<BlockUUID | boolean>
+
+  /**
+   * insert a string at the current cursor
+   */
+  insertAtEditingCursor: (content: string) => Promise<void>
+
+  restoreEditingCursor: () => Promise<void>
+
+  exitEditingMode: (selectBlock?: boolean) => Promise<void>
+
+  getEditingCursorPosition: () => Promise<BlockCursorPosition | null>
+
+  getEditingBlockContent: () => Promise<string>
+
+  getCurrentPage: () => Promise<PageEntity | BlockEntity | null>
+
+  getCurrentBlock: () => Promise<BlockEntity | null>
+
+  /**
+   * get all blocks of the current page as a tree structure
+   *
+   * @example
+   * ```ts
+   * const blocks = await logseq.Editor.getCurrentPageBlocksTree()
+   * initMindMap(blocks)
+   * ```
+   */
+  getCurrentPageBlocksTree: () => Promise<Array<BlockEntity>>
+
+  /**
+   * get all blocks for the specified page
+   *
+   * @param srcPage - the page name or uuid
+   */
+  getPageBlocksTree: (srcPage: PageIdentity) => Promise<Array<BlockEntity>>
+
+  insertBlock: (
+    srcBlock: BlockIdentity,
+    content: string,
+    opts?: Partial<{ before: boolean; sibling: boolean; props: {} }>
+  ) => Promise<BlockEntity | null>
+
+  insertBatchBlock: (
+    srcBlock: BlockIdentity,
+    batch: IBatchBlock | Array<IBatchBlock>,
+    opts?: Partial<{ before: boolean, sibling: boolean }>
+  ) => Promise<null>
+
+  updateBlock: (
+    srcBlock: BlockIdentity,
+    content: string,
+    opts?: Partial<{ props: {} }>
+  ) => Promise<void>
+
+  removeBlock: (
+    srcBlock: BlockIdentity,
+    opts?: Partial<{ includeChildren: boolean }>
+  ) => Promise<void>
+
+  getBlock: (
+    srcBlock: BlockIdentity | BlockID,
+    opts?: Partial<{ includeChildren: boolean }>
+  ) => Promise<BlockEntity | null>
+
+  getPage: (
+    srcPage: PageIdentity | BlockID,
+    opts?: Partial<{ includeChildren: boolean }>
+  ) => Promise<PageEntity | null>
+
+  getPreviousSiblingBlock: (
+    srcBlock: BlockIdentity
+  ) => Promise<BlockEntity | null>
+
+  getNextSiblingBlock: (srcBlock: BlockIdentity) => Promise<BlockEntity | null>
+
+  moveBlock: (
+    srcBlock: BlockIdentity,
+    targetBlock: BlockIdentity,
+    opts?: Partial<{ before: boolean; children: boolean }>
+  ) => Promise<void>
+  editBlock: (srcBlock: BlockIdentity, opts?: { pos: number }) => Promise<void>
+
+  upsertBlockProperty: (
+    block: BlockIdentity,
+    key: string,
+    value: any
+  ) => Promise<void>
+
+  removeBlockProperty: (block: BlockIdentity, key: string) => Promise<void>
+
+  getBlockProperty: (block: BlockIdentity, key: string) => Promise<any>
+
+  getBlockProperties: (block: BlockIdentity) => Promise<any>
+}
+
+/**
+ * Datascript related APIs
+ */
+export interface IDBProxy {
+  /**
+   * Run a datascript query
+   */
+  datascriptQuery: <T = any>(query: string) => Promise<T>
+}
+
+export interface ILSPluginThemeManager extends EventEmitter {
+  themes: Map<PluginLocalIdentity, Array<ThemeOptions>>
+
+  registerTheme (id: PluginLocalIdentity, opt: ThemeOptions): Promise<void>
+
+  unregisterTheme (id: PluginLocalIdentity): Promise<void>
+
+  selectTheme (opt?: ThemeOptions): Promise<void>
+}
+
+export type LSPluginUserEvents = 'ui:visible:changed' | 'settings:changed'
+
+export interface ILSPluginUser extends EventEmitter<LSPluginUserEvents> {
+  /**
+   * Connection status with the main app
+   */
+  connected: boolean
+
+  /**
+   * Duplex message caller
+   */
+  caller: LSPluginCaller
+
+  /**
+   * The plugin configurations from package.json
+   */
+  baseInfo: LSPluginBaseInfo
+
+  /**
+   * The plugin user settings
+   */
+  settings?: LSPluginBaseInfo['settings']
+
+  /**
+   * The main app is ready to run the plugin
+   */
+  ready (model?: Record<string, any>): Promise<any>
+
+  ready (callback?: (e: any) => void | {}): Promise<any>
+
+  ready (
+    model?: Record<string, any>,
+    callback?: (e: any) => void | {}
+  ): Promise<any>
+
+  beforeunload: (callback: () => Promise<void>) => void
+
+  provideModel (model: Record<string, any>): this
+
+  provideTheme (theme: ThemeOptions): this
+
+  /**
+   * Inject custom css for the plugin
+   */
+  provideStyle (style: StyleString | StyleOptions): this
+
+  /**
+   * Inject custom UI at specific DOM node
+   * @example
+   * ```ts
+   * logseq.provideUI({
+   * key: 'open-calendar',
+   * path: '#search',
+   * template: `
+   *  <a data-on-click="openCalendar" onclick="alert('abc')" style="opacity: .6; display: inline-flex; padding-left: 3px;">
+   *    <i class="iconfont icon-Calendaralt2"></i>
+   *  </a>
+   * `
+   * })
+   * ```
+   */
+  provideUI (ui: UIOptions): this
+
+  updateSettings (attrs: Record<string, any>): void
+
+  setMainUIAttrs (attrs: Record<string, any>): void
+
+  setMainUIInlineStyle (style: CSS.Properties): void
+
+  showMainUI (): void
+
+  hideMainUI (opts?: { restoreEditingCursor: boolean }): void
+
+  toggleMainUI (): void
+
+  isMainUIVisible: boolean
+
+  App: IAppProxy & Record<string, any>
+  Editor: IEditorProxy & Record<string, any>
+  DB: IDBProxy
+}
\ No newline at end of file
diff --git a/libs/src/LSPlugin.user.ts b/libs/src/LSPlugin.user.ts
new file mode 100644
index 0000000000..49e75df6e5
--- /dev/null
+++ b/libs/src/LSPlugin.user.ts
@@ -0,0 +1,360 @@
+import { deepMerge } from './helpers'
+import { LSPluginCaller } from './LSPlugin.caller'
+import {
+  IAppProxy, IDBProxy,
+  IEditorProxy,
+  ILSPluginUser,
+  LSPluginBaseInfo,
+  LSPluginUserEvents,
+  SlashCommandAction,
+  BlockCommandCallback,
+  StyleString,
+  ThemeOptions,
+  UIOptions
+} from './LSPlugin'
+import Debug from 'debug'
+import * as CSS from 'csstype'
+import { snakeCase } from 'snake-case'
+import EventEmitter from 'eventemitter3'
+
+declare global {
+  interface Window {
+    __LSP__HOST__: boolean
+  }
+}
+
+const debug = Debug('LSPlugin:user')
+
+const app: Partial<IAppProxy> = {}
+
+let registeredCmdUid = 0
+
+const editor: Partial<IEditorProxy> = {
+  registerSlashCommand (
+    this: LSPluginUser,
+    tag: string,
+    actions: BlockCommandCallback | Array<SlashCommandAction>
+  ) {
+    debug('Register slash command #', this.baseInfo.id, tag, actions)
+
+    if (typeof actions === 'function') {
+      actions = [
+        ['editor/clear-current-slash', false],
+        ['editor/restore-saved-cursor'],
+        ['editor/hook', actions]
+      ]
+    }
+
+    actions = actions.map((it) => {
+      const [tag, ...args] = it
+
+      switch (tag) {
+        case 'editor/hook':
+          let key = args[0]
+          let fn = () => {
+            this.caller?.callUserModel(key)
+          }
+
+          if (typeof key === 'function') {
+            fn = key
+          }
+
+          const eventKey = `SlashCommandHook${tag}${++registeredCmdUid}`
+
+          it[1] = eventKey
+
+          // register command listener
+          this.Editor['on' + eventKey](fn)
+          break
+        default:
+      }
+
+      return it
+    })
+
+    this.caller?.call(`api:call`, {
+      method: 'register-plugin-slash-command',
+      args: [this.baseInfo.id, [tag, actions]]
+    })
+
+    return false
+  },
+
+  registerBlockContextMenu (
+    this: LSPluginUser,
+    tag: string,
+    action: BlockCommandCallback
+  ): boolean {
+    if (typeof action !== 'function') {
+      return false
+    }
+
+    const key = tag
+    const label = tag
+    const type = 'block-context-menu'
+    const eventKey = `SimpleCommandHook${tag}${++registeredCmdUid}`
+
+    this.Editor['on' + eventKey](action)
+
+    this.caller?.call(`api:call`, {
+      method: 'register-plugin-simple-command',
+      args: [this.baseInfo.id, [{ key, label, type }, ['editor/hook', eventKey]]]
+    })
+
+    return false
+  }
+}
+
+const db: Partial<IDBProxy> = {}
+
+type uiState = {
+  key?: number,
+  visible: boolean
+}
+
+const KEY_MAIN_UI = 0
+
+/**
+ * User plugin instance
+ * @public
+ */
+export class LSPluginUser extends EventEmitter<LSPluginUserEvents> implements ILSPluginUser {
+  /**
+   * @private
+   */
+  private _connected: boolean = false
+
+  /**
+   * ui frame identities
+   * @private
+   */
+  private _ui = new Map<number, uiState>()
+
+  /**
+   * handler of before unload plugin
+   * @private
+   */
+  private _beforeunloadCallback?: (e: any) => Promise<void>
+
+  /**
+   * @param _baseInfo
+   * @param _caller
+   */
+  constructor (
+    private _baseInfo: LSPluginBaseInfo,
+    private _caller: LSPluginCaller
+  ) {
+    super()
+
+    _caller.on('settings:changed', (payload) => {
+      const b = Object.assign({}, this.settings)
+      const a = Object.assign(this._baseInfo.settings, payload)
+      this.emit('settings:changed', { ...a }, b)
+    })
+
+    _caller.on('beforeunload', async (payload) => {
+      const { actor, ...rest } = payload
+      const cb = this._beforeunloadCallback
+      if (!cb || !actor) return
+
+      try {
+        cb && await cb(rest)
+        actor.resolve(null)
+      } catch (e) {
+        console.debug(`${_caller.debugTag} [beforeunload] `, e)
+        actor.reject(e)
+      }
+    })
+  }
+
+  async ready (
+    model?: any,
+    callback?: any
+  ) {
+    if (this._connected) return
+
+    try {
+
+      if (typeof model === 'function') {
+        callback = model
+        model = {}
+      }
+
+      let baseInfo = await this._caller.connectToParent(model)
+
+      baseInfo = deepMerge(this._baseInfo, baseInfo)
+
+      this._connected = true
+
+      if (baseInfo?.id) {
+        this._caller.debugTag = `#${baseInfo.id} [${baseInfo.name}]`
+      }
+
+      callback && callback.call(this, baseInfo)
+    } catch (e) {
+      console.error('[LSPlugin Ready Error]', e)
+    }
+  }
+
+  beforeunload (callback: (e: any) => Promise<void>): void {
+    if (typeof callback !== 'function') return
+    this._beforeunloadCallback = callback
+  }
+
+  provideModel (model: Record<string, any>) {
+    this.caller._extendUserModel(model)
+    return this
+  }
+
+  provideTheme (theme: ThemeOptions) {
+    this.caller.call('provider:theme', theme)
+    return this
+  }
+
+  provideStyle (style: StyleString) {
+    this.caller.call('provider:style', style)
+    return this
+  }
+
+  provideUI (ui: UIOptions) {
+    this.caller.call('provider:ui', ui)
+    return this
+  }
+
+  updateSettings (attrs: Record<string, any>) {
+    this.caller.call('settings:update', attrs)
+    // TODO: update associated baseInfo settings
+  }
+
+  setMainUIAttrs (attrs: Record<string, any>): void {
+    this.caller.call('main-ui:attrs', attrs)
+  }
+
+  setMainUIInlineStyle (style: CSS.Properties): void {
+    this.caller.call('main-ui:style', style)
+  }
+
+  hideMainUI (opts?: { restoreEditingCursor: boolean }): void {
+    const payload = { key: KEY_MAIN_UI, visible: false, cursor: opts?.restoreEditingCursor }
+    this.caller.call('main-ui:visible', payload)
+    this.emit('ui:visible:changed', payload)
+    this._ui.set(payload.key, payload)
+  }
+
+  showMainUI (): void {
+    const payload = { key: KEY_MAIN_UI, visible: true }
+    this.caller.call('main-ui:visible', payload)
+    this.emit('ui:visible:changed', payload)
+    this._ui.set(payload.key, payload)
+  }
+
+  toggleMainUI (): void {
+    const payload = { key: KEY_MAIN_UI, toggle: true }
+    const state = this._ui.get(payload.key)
+    if (state && state.visible) {
+      this.hideMainUI()
+    } else {
+      this.showMainUI()
+    }
+  }
+
+  get isMainUIVisible (): boolean {
+    const state = this._ui.get(0)
+    return Boolean(state && state.visible)
+  }
+
+  get connected (): boolean {
+    return this._connected
+  }
+
+  get baseInfo (): LSPluginBaseInfo {
+    return this._baseInfo
+  }
+
+  get settings () {
+    return this.baseInfo?.settings
+  }
+
+  get caller (): LSPluginCaller {
+    return this._caller
+  }
+
+  /**
+   * @internal
+   */
+  _makeUserProxy (
+    target: any,
+    tag?: 'app' | 'editor' | 'db'
+  ) {
+    const that = this
+    const caller = this.caller
+
+    return new Proxy(target, {
+      get (target: any, propKey, receiver) {
+        const origMethod = target[propKey]
+
+        return function (this: any, ...args: any) {
+          if (origMethod) {
+            const ret = origMethod.apply(that, args)
+            if (ret === false) return
+          }
+
+          // Handle hook
+          if (tag) {
+            const hookMatcher = propKey.toString().match(/^(once|off|on)/i)
+
+            if (hookMatcher != null) {
+              const f = hookMatcher[0].toLowerCase()
+              const s = hookMatcher.input!
+              const e = s.slice(f.length)
+
+              const type = `hook:${tag}:${snakeCase(e)}`
+              const handler = args[0]
+              caller[f](type, handler)
+              return f !== 'off' ? () => (caller.off(type, handler)) : void 0
+            }
+          }
+
+          // Call host
+          return caller.callAsync(`api:call`, {
+            method: propKey,
+            args: args
+          })
+        }
+      }
+    })
+  }
+
+  /**
+   * The interface methods of {@link IAppProxy}
+   */
+  get App (): IAppProxy {
+    return this._makeUserProxy(app, 'app')
+  }
+
+  get Editor (): IEditorProxy {
+    return this._makeUserProxy(editor, 'editor')
+  }
+
+  get DB (): IDBProxy {
+    return this._makeUserProxy(db)
+  }
+}
+
+export * from './LSPlugin'
+
+/**
+ * @internal
+ */
+export function setupPluginUserInstance (
+  pluginBaseInfo: LSPluginBaseInfo,
+  pluginCaller: LSPluginCaller
+) {
+  return new LSPluginUser(pluginBaseInfo, pluginCaller)
+}
+
+if (window.__LSP__HOST__ == null) { // Entry of iframe mode
+  const caller = new LSPluginCaller(null)
+  // @ts-ignore
+  window.logseq = setupPluginUserInstance({} as any, caller)
+}
diff --git a/libs/src/helpers.ts b/libs/src/helpers.ts
new file mode 100644
index 0000000000..a55beea1d6
--- /dev/null
+++ b/libs/src/helpers.ts
@@ -0,0 +1,289 @@
+import { StyleString, UIOptions } from './LSPlugin'
+import { PluginLocal } from './LSPlugin.core'
+import { snakeCase } from 'snake-case'
+
+interface IObject {
+  [key: string]: any;
+}
+
+declare global {
+  interface Window {
+    api: any
+    apis: any
+  }
+}
+
+export function isObject (item: any) {
+  return (item === Object(item) && !Array.isArray(item))
+}
+
+export function deepMerge (
+  target: IObject,
+  ...sources: Array<IObject>
+) {
+  // return the target if no sources passed
+  if (!sources.length) {
+    return target
+  }
+
+  const result: IObject = target
+
+  if (isObject(result)) {
+    const len: number = sources.length
+
+    for (let i = 0; i < len; i += 1) {
+      const elm: any = sources[i]
+
+      if (isObject(elm)) {
+        for (const key in elm) {
+          if (elm.hasOwnProperty(key)) {
+            if (isObject(elm[key])) {
+              if (!result[key] || !isObject(result[key])) {
+                result[key] = {}
+              }
+              deepMerge(result[key], elm[key])
+            } else {
+              if (Array.isArray(result[key]) && Array.isArray(elm[key])) {
+                // concatenate the two arrays and remove any duplicate primitive values
+                result[key] = Array.from(new Set(result[key].concat(elm[key])))
+              } else {
+                result[key] = elm[key]
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+export function genID () {
+  // Math.random should be unique because of its seeding algorithm.
+  // Convert it to base 36 (numbers + letters), and grab the first 9 characters
+  // after the decimal.
+  return '_' + Math.random().toString(36).substr(2, 9)
+}
+
+export function ucFirst (str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export function withFileProtocol (path: string) {
+  if (!path) return ''
+  const reg = /^(http|file|assets)/
+
+  if (!reg.test(path)) {
+    path = 'file://' + path
+  }
+
+  return path
+}
+
+/**
+ * @param timeout milliseconds
+ * @param tag string
+ */
+export function deferred<T = any> (timeout?: number, tag?: string) {
+  let resolve: any, reject: any
+  let settled = false
+  const timeFn = (r: Function) => {
+    return (v: T) => {
+      timeout && clearTimeout(timeout)
+      r(v)
+      settled = true
+    }
+  }
+
+  const promise = new Promise<T>((resolve1, reject1) => {
+    resolve = timeFn(resolve1)
+    reject = timeFn(reject1)
+
+    if (timeout) {
+      // @ts-ignore
+      timeout = setTimeout(() => reject(new Error(`[deferred timeout] ${tag}`)), timeout)
+    }
+  })
+
+  return {
+    created: Date.now(),
+    setTag: (t: string) => tag = t,
+    resolve, reject, promise,
+    get settled () {
+      return settled
+    }
+  }
+}
+
+export function invokeHostExportedApi (
+  method: string,
+  ...args: Array<any>
+) {
+  const method1 = snakeCase(method)
+
+  // @ts-ignore
+  const logseqHostExportedApi = window.logseq?.api || {}
+
+  const fn = logseqHostExportedApi[method1] || window.apis[method1] ||
+    logseqHostExportedApi[method] || window.apis[method]
+
+  if (!fn) {
+    throw new Error(`Not existed method #${method}`)
+  }
+  return typeof fn !== 'function' ? fn : fn.apply(null, args)
+}
+
+export function setupIframeSandbox (
+  props: Record<string, any>,
+  target: HTMLElement
+) {
+  const iframe = document.createElement('iframe')
+
+  iframe.classList.add('lsp-iframe-sandbox')
+
+  Object.entries(props).forEach(([k, v]) => {
+    iframe.setAttribute(k, v)
+  })
+
+  target.appendChild(iframe)
+
+  return async () => {
+    target.removeChild(iframe)
+  }
+}
+
+export function setupInjectedStyle (
+  style: StyleString,
+  attrs: Record<string, any>
+) {
+  const key = attrs['data-injected-style']
+  let el = key && document.querySelector(`[data-injected-style=${key}]`)
+
+  if (el) {
+    el.textContent = style
+    return
+  }
+
+  el = document.createElement('style')
+  el.textContent = style
+
+  attrs && Object.entries(attrs).forEach(([k, v]) => {
+    el.setAttribute(k, v)
+  })
+
+  document.head.append(el)
+
+  return () => {
+    document.head.removeChild(el)
+  }
+}
+
+export function setupInjectedUI (
+  this: PluginLocal,
+  ui: UIOptions,
+  attrs: Record<string, any>
+) {
+  const pl = this
+  let selector = ''
+
+  if ('slot' in ui) {
+    selector = `#${ui.slot}`
+  } else {
+    selector = ui.path
+  }
+
+  const target = selector && document.querySelector(selector)
+  if (!target) {
+    console.error(`${this.debugTag} can not resolve selector target ${selector}`)
+    return
+  }
+
+  const key = `${ui.key}-${pl.id}`
+
+  let el = document.querySelector(`div[data-injected-ui="${key}"]`) as HTMLElement
+
+  if (el) {
+    el.innerHTML = ui.template
+    return
+  }
+
+  el = document.createElement('div')
+  el.dataset.injectedUi = key || ''
+
+  // TODO: Support more
+  el.innerHTML = ui.template
+
+  attrs && Object.entries(attrs).forEach(([k, v]) => {
+    el.setAttribute(k, v)
+  })
+
+  target.appendChild(el);
+
+  // TODO: How handle events
+  ['click', 'focus', 'focusin', 'focusout', 'blur', 'dblclick',
+    'keyup', 'keypress', 'keydown', 'change', 'input'].forEach((type) => {
+    el.addEventListener(type, (e) => {
+      const target = e.target! as HTMLElement
+      const trigger = target.closest(`[data-on-${type}]`) as HTMLElement
+      if (!trigger) return
+
+      const msgType = trigger.dataset[`on${ucFirst(type)}`]
+      msgType && pl.caller?.callUserModel(msgType, transformableEvent(trigger, e))
+    }, false)
+  })
+
+  return () => {
+    target!.removeChild(el)
+  }
+}
+
+export function transformableEvent (target: HTMLElement, e: Event) {
+  const obj: any = {}
+
+  if (target) {
+    const ds = target.dataset
+    const FLAG_RECT = 'rect'
+
+    ;['value', 'id', 'className',
+      'dataset', FLAG_RECT
+    ].forEach((k) => {
+      let v: any
+
+      switch (k) {
+        case FLAG_RECT:
+          if (!ds.hasOwnProperty(FLAG_RECT)) return
+          v = target.getBoundingClientRect().toJSON()
+          break
+        default:
+          v = target[k]
+      }
+
+      if (typeof v === 'object') {
+        v = { ...v }
+      }
+
+      obj[k] = v
+    })
+  }
+
+  return obj
+}
+
+let injectedThemeEffect: any = null
+
+export function setupInjectedTheme (url?: string) {
+  injectedThemeEffect?.call()
+
+  if (!url) return
+
+  const link = document.createElement('link')
+  link.rel = 'stylesheet'
+  link.href = url
+  document.head.appendChild(link)
+
+  return (injectedThemeEffect = () => {
+    document.head.removeChild(link)
+    injectedThemeEffect = null
+  })
+}
diff --git a/libs/tsconfig.json b/libs/tsconfig.json
new file mode 100644
index 0000000000..799d5f9631
--- /dev/null
+++ b/libs/tsconfig.json
@@ -0,0 +1,88 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "ESNext",
+    /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "ESNext",
+    /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    "allowJs": true,
+    /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    "jsx": "react",
+    /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true,
+    /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    "sourceMap": false,
+    /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "dist",
+    /* Redirect output structure to the directory. */
+    "rootDir": "src",
+    /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    //    "noEmit": true,
+    /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    // "strict": true,
+    /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    "strictNullChecks": true,
+    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    "strictPropertyInitialization": true,
+    /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",
+    /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,
+    /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,
+    /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true
+    /* Disallow inconsistently-cased references to the same file. */
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}
diff --git a/libs/webpack.config.core.js b/libs/webpack.config.core.js
new file mode 100644
index 0000000000..1bc1dc255f
--- /dev/null
+++ b/libs/webpack.config.core.js
@@ -0,0 +1,32 @@
+const webpack = require('webpack')
+const path = require('path')
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
+
+module.exports = {
+  entry: './src/LSPlugin.core.ts',
+  devtool: 'inline-source-map',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+  },
+  plugins: [
+    new webpack.ProvidePlugin({
+      process: 'process/browser',
+    }),
+    // new BundleAnalyzerPlugin()
+  ],
+  output: {
+    library: 'LSPlugin',
+    libraryTarget: 'umd',
+    filename: 'lsplugin.core.js',
+    path: path.resolve(__dirname, '../resources/js'),
+  },
+}
\ No newline at end of file
diff --git a/libs/webpack.config.js b/libs/webpack.config.js
new file mode 100644
index 0000000000..8c511c3053
--- /dev/null
+++ b/libs/webpack.config.js
@@ -0,0 +1,27 @@
+const path = require('path')
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
+
+module.exports = {
+  entry: './src/LSPlugin.user.ts',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+  },
+  plugins: [
+    // new BundleAnalyzerPlugin()
+  ],
+  output: {
+    library: "LSPluginEntry",
+    libraryTarget: "umd",
+    filename: 'lsplugin.user.js',
+    path: path.resolve(__dirname, 'dist')
+  },
+}
\ No newline at end of file
diff --git a/libs/yarn.lock b/libs/yarn.lock
new file mode 100644
index 0000000000..69b807a33d
--- /dev/null
+++ b/libs/yarn.lock
@@ -0,0 +1,1256 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@discoveryjs/json-ext@^0.5.0":
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.2.tgz#8f03a22a04de437254e8ce8cc84ba39689288752"
+  integrity sha512-HyYEUDeIj5rRQU2Hk5HTB2uHsbRQpF70nvMhVzi+VJR0X+xNEhjPui4/kBf3VeH/wqD28PT4sVOm8qqLjBrSZg==
+
+"@polka/url@^1.0.0-next.9":
+  version "1.0.0-next.11"
+  resolved "https://registry.yarnpkg.com/@polka/url/-/url-1.0.0-next.11.tgz#aeb16f50649a91af79dbe36574b66d0f9e4d9f71"
+  integrity sha512-3NsZsJIA/22P3QUyrEDNA2D133H4j224twJrdipXN38dpnIOzAbUDtOwkcJ5pXmn75w7LSQDjA4tO9dm1XlqlA==
+
+"@types/debug@^4.1.5":
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.5.tgz#b14efa8852b7768d898906613c23f688713e02cd"
+  integrity sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==
+
+"@types/dompurify@^2.2.1":
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/@types/dompurify/-/dompurify-2.2.1.tgz#eebf3af8afe2f577a53acab9d98a3a4cb04bbbe7"
+  integrity sha512-3JwbEeRVQ3n6+JgBW/hCdkydRk9/vWT+UEglcXEJqLJEcUganDH37zlfLznxPKTZZfDqA9K229l1qN458ubcOQ==
+  dependencies:
+    "@types/trusted-types" "*"
+
+"@types/eslint-scope@^3.7.0":
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.0.tgz#4792816e31119ebd506902a482caec4951fabd86"
+  integrity sha512-O/ql2+rrCUe2W2rs7wMR+GqPRcgB6UiqN5RhrR5xruFlY7l9YLMn0ZkDzjoHLeiFkR8MCQZVudUuuvQ2BLC9Qw==
+  dependencies:
+    "@types/eslint" "*"
+    "@types/estree" "*"
+
+"@types/eslint@*":
+  version "7.2.6"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-7.2.6.tgz#5e9aff555a975596c03a98b59ecd103decc70c3c"
+  integrity sha512-I+1sYH+NPQ3/tVqCeUSBwTE/0heyvtXqpIopUUArlBm0Kpocb8FbMa3AZ/ASKIFpN3rnEx932TTXDbt9OXsNDw==
+  dependencies:
+    "@types/estree" "*"
+    "@types/json-schema" "*"
+
+"@types/estree@*", "@types/estree@^0.0.46":
+  version "0.0.46"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.46.tgz#0fb6bfbbeabd7a30880504993369c4bf1deab1fe"
+  integrity sha512-laIjwTQaD+5DukBZaygQ79K1Z0jb1bPEMRrkXSLjtCcZm+abyp5YbrqpSLzD42FwWW6gK/aS4NYpJ804nG2brg==
+
+"@types/json-schema@*", "@types/json-schema@^7.0.6":
+  version "7.0.7"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
+  integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
+
+"@types/lodash-es@^4.17.4":
+  version "4.17.4"
+  resolved "https://registry.yarnpkg.com/@types/lodash-es/-/lodash-es-4.17.4.tgz#b2e440d2bf8a93584a9fd798452ec497986c9b97"
+  integrity sha512-BBz79DCJbD2CVYZH67MBeHZRX++HF+5p8Mo5MzjZi64Wac39S3diedJYHZtScbRVf4DjZyN6LzA0SB0zy+HSSQ==
+  dependencies:
+    "@types/lodash" "*"
+
+"@types/lodash@*":
+  version "4.14.168"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.168.tgz#fe24632e79b7ade3f132891afff86caa5e5ce008"
+  integrity sha512-oVfRvqHV/V6D1yifJbVRU3TMp8OT6o6BG+U9MkwuJ3U8/CsDHvalRpsxBqivn71ztOFZBTfJMvETbqHiaNSj7Q==
+
+"@types/node@*":
+  version "14.14.31"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.31.tgz#72286bd33d137aa0d152d47ec7c1762563d34055"
+  integrity sha512-vFHy/ezP5qI0rFgJ7aQnjDXwAMrG0KqqIH7tQG5PPv3BWBayOPIQNBjVc/P6hhdZfMx51REc6tfDNXHUio893g==
+
+"@types/postmate@^1.5.1":
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/@types/postmate/-/postmate-1.5.1.tgz#56a506c371a7b4388beebacb4420838c2c3c4a2b"
+  integrity sha512-sFia2ycFNrxf1YZS59ShTDkMwhUlOYWAw7EslLePF52x5czUDrvdqB4f3eCXCiQp7yXpqHqwPCf4OBvCTqbaWw==
+
+"@types/trusted-types@*":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@types/trusted-types/-/trusted-types-2.0.0.tgz#aee6e868fcef74f2b8c71614b6df81a601a42f17"
+  integrity sha512-I8MnZqNXsOLHsU111oHbn3khtvKMi5Bn4qVFsIWSJcCP1KKDiXX5AEw8UPk0nSopeC+Hvxt6yAy1/a5PailFqg==
+
+"@webassemblyjs/ast@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.0.tgz#a5aa679efdc9e51707a4207139da57920555961f"
+  integrity sha512-kX2W49LWsbthrmIRMbQZuQDhGtjyqXfEmmHyEi4XWnSZtPmxY0+3anPIzsnRb45VH/J55zlOfWvZuY47aJZTJg==
+  dependencies:
+    "@webassemblyjs/helper-numbers" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+
+"@webassemblyjs/floating-point-hex-parser@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.0.tgz#34d62052f453cd43101d72eab4966a022587947c"
+  integrity sha512-Q/aVYs/VnPDVYvsCBL/gSgwmfjeCb4LW8+TMrO3cSzJImgv8lxxEPM2JA5jMrivE7LSz3V+PFqtMbls3m1exDA==
+
+"@webassemblyjs/helper-api-error@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.0.tgz#aaea8fb3b923f4aaa9b512ff541b013ffb68d2d4"
+  integrity sha512-baT/va95eXiXb2QflSx95QGT5ClzWpGaa8L7JnJbgzoYeaA27FCvuBXU758l+KXWRndEmUXjP0Q5fibhavIn8w==
+
+"@webassemblyjs/helper-buffer@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.0.tgz#d026c25d175e388a7dbda9694e91e743cbe9b642"
+  integrity sha512-u9HPBEl4DS+vA8qLQdEQ6N/eJQ7gT7aNvMIo8AAWvAl/xMrcOSiI2M0MAnMCy3jIFke7bEee/JwdX1nUpCtdyA==
+
+"@webassemblyjs/helper-numbers@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.0.tgz#7ab04172d54e312cc6ea4286d7d9fa27c88cd4f9"
+  integrity sha512-DhRQKelIj01s5IgdsOJMKLppI+4zpmcMQ3XboFPLwCpSNH6Hqo1ritgHgD0nqHeSYqofA6aBN/NmXuGjM1jEfQ==
+  dependencies:
+    "@webassemblyjs/floating-point-hex-parser" "1.11.0"
+    "@webassemblyjs/helper-api-error" "1.11.0"
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/helper-wasm-bytecode@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.0.tgz#85fdcda4129902fe86f81abf7e7236953ec5a4e1"
+  integrity sha512-MbmhvxXExm542tWREgSFnOVo07fDpsBJg3sIl6fSp9xuu75eGz5lz31q7wTLffwL3Za7XNRCMZy210+tnsUSEA==
+
+"@webassemblyjs/helper-wasm-section@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.0.tgz#9ce2cc89300262509c801b4af113d1ca25c1a75b"
+  integrity sha512-3Eb88hcbfY/FCukrg6i3EH8H2UsD7x8Vy47iVJrP967A9JGqgBVL9aH71SETPx1JrGsOUVLo0c7vMCN22ytJew==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+
+"@webassemblyjs/ieee754@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.0.tgz#46975d583f9828f5d094ac210e219441c4e6f5cf"
+  integrity sha512-KXzOqpcYQwAfeQ6WbF6HXo+0udBNmw0iXDmEK5sFlmQdmND+tr773Ti8/5T/M6Tl/413ArSJErATd8In3B+WBA==
+  dependencies:
+    "@xtuc/ieee754" "^1.2.0"
+
+"@webassemblyjs/leb128@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.0.tgz#f7353de1df38aa201cba9fb88b43f41f75ff403b"
+  integrity sha512-aqbsHa1mSQAbeeNcl38un6qVY++hh8OpCOzxhixSYgbRfNWcxJNJQwe2rezK9XEcssJbbWIkblaJRwGMS9zp+g==
+  dependencies:
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/utf8@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.0.tgz#86e48f959cf49e0e5091f069a709b862f5a2cadf"
+  integrity sha512-A/lclGxH6SpSLSyFowMzO/+aDEPU4hvEiooCMXQPcQFPPJaYcPQNKGOCLUySJsYJ4trbpr+Fs08n4jelkVTGVw==
+
+"@webassemblyjs/wasm-edit@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.0.tgz#ee4a5c9f677046a210542ae63897094c2027cb78"
+  integrity sha512-JHQ0damXy0G6J9ucyKVXO2j08JVJ2ntkdJlq1UTiUrIgfGMmA7Ik5VdC/L8hBK46kVJgujkBIoMtT8yVr+yVOQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/helper-wasm-section" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+    "@webassemblyjs/wasm-opt" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
+    "@webassemblyjs/wast-printer" "1.11.0"
+
+"@webassemblyjs/wasm-gen@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.0.tgz#3cdb35e70082d42a35166988dda64f24ceb97abe"
+  integrity sha512-BEUv1aj0WptCZ9kIS30th5ILASUnAPEvE3tVMTrItnZRT9tXCLW2LEXT8ezLw59rqPP9klh9LPmpU+WmRQmCPQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/ieee754" "1.11.0"
+    "@webassemblyjs/leb128" "1.11.0"
+    "@webassemblyjs/utf8" "1.11.0"
+
+"@webassemblyjs/wasm-opt@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.0.tgz#1638ae188137f4bb031f568a413cd24d32f92978"
+  integrity sha512-tHUSP5F4ywyh3hZ0+fDQuWxKx3mJiPeFufg+9gwTpYp324mPCQgnuVKwzLTZVqj0duRDovnPaZqDwoyhIO8kYg==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
+
+"@webassemblyjs/wasm-parser@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.0.tgz#3e680b8830d5b13d1ec86cc42f38f3d4a7700754"
+  integrity sha512-6L285Sgu9gphrcpDXINvm0M9BskznnzJTE7gYkjDbxET28shDqp27wpruyx3C2S/dvEwiigBwLA1cz7lNUi0kw==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-api-error" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/ieee754" "1.11.0"
+    "@webassemblyjs/leb128" "1.11.0"
+    "@webassemblyjs/utf8" "1.11.0"
+
+"@webassemblyjs/wast-printer@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.0.tgz#680d1f6a5365d6d401974a8e949e05474e1fab7e"
+  integrity sha512-Fg5OX46pRdTgB7rKIUojkh9vXaVN6sGYCnEiJN1GYkb0RPwShZXp6KTDqmoMdQPKhcroOXh3fEzmkWmCYaKYhQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@xtuc/long" "4.2.2"
+
+"@webpack-cli/configtest@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/configtest/-/configtest-1.0.1.tgz#241aecfbdc715eee96bed447ed402e12ec171935"
+  integrity sha512-B+4uBUYhpzDXmwuo3V9yBH6cISwxEI4J+NO5ggDaGEEHb0osY/R7MzeKc0bHURXQuZjMM4qD+bSJCKIuI3eNBQ==
+
+"@webpack-cli/info@^1.2.2":
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/info/-/info-1.2.2.tgz#ef3c0cd947a1fa083e174a59cb74e0b6195c236c"
+  integrity sha512-5U9kUJHnwU+FhKH4PWGZuBC1hTEPYyxGSL5jjoBI96Gx8qcYJGOikpiIpFoTq8mmgX3im2zAo2wanv/alD74KQ==
+  dependencies:
+    envinfo "^7.7.3"
+
+"@webpack-cli/serve@^1.3.0":
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/serve/-/serve-1.3.0.tgz#2730c770f5f1f132767c63dcaaa4ec28f8c56a6c"
+  integrity sha512-k2p2VrONcYVX1wRRrf0f3X2VGltLWcv+JzXRBDmvCxGlCeESx4OXw91TsWeKOkp784uNoVQo313vxJFHXPPwfw==
+
+"@xtuc/ieee754@^1.2.0":
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
+  integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
+
+"@xtuc/long@4.2.2":
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
+  integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
+
+acorn-walk@^8.0.0:
+  version "8.0.2"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
+  integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
+
+acorn@^8.0.4:
+  version "8.0.5"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.0.5.tgz#a3bfb872a74a6a7f661bc81b9849d9cac12601b7"
+  integrity sha512-v+DieK/HJkJOpFBETDJioequtc3PfxsWMaxIdIwujtF7FEV/MAyDQLlm6/zPvr7Mix07mLh6ccVwIsloceodlg==
+
+ajv-keywords@^3.5.2:
+  version "3.5.2"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
+  integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
+
+ajv@^6.12.5:
+  version "6.12.6"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
+  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
+ansi-colors@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
+  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
+
+ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
+big.js@^5.2.2:
+  version "5.2.2"
+  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
+  integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
+
+braces@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
+  dependencies:
+    fill-range "^7.0.1"
+
+browserslist@^4.14.5:
+  version "4.16.3"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
+  integrity sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==
+  dependencies:
+    caniuse-lite "^1.0.30001181"
+    colorette "^1.2.1"
+    electron-to-chromium "^1.3.649"
+    escalade "^3.1.1"
+    node-releases "^1.1.70"
+
+buffer-from@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+  integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
+
+caniuse-lite@^1.0.30001181:
+  version "1.0.30001196"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001196.tgz#00518a2044b1abf3e0df31fadbe5ed90b63f4e64"
+  integrity sha512-CPvObjD3ovWrNBaXlAIGWmg2gQQuJ5YhuciUOjPRox6hIQttu8O+b51dx6VIpIY9ESd2d0Vac1RKpICdG4rGUg==
+
+chalk@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
+  integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chrome-trace-event@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.2.tgz#234090ee97c7d4ad1a2c4beae27505deffc608a4"
+  integrity sha512-9e/zx1jw7B4CO+c/RXoCsfg/x1AfUBioy4owYH0bJprEYAx5hRFLRhWBqHAG57D0ZM4H7vxbP7bPe0VwhQRYDQ==
+  dependencies:
+    tslib "^1.9.0"
+
+clone-deep@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
+  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
+  dependencies:
+    is-plain-object "^2.0.4"
+    kind-of "^6.0.2"
+    shallow-clone "^3.0.0"
+
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
+color-name@~1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
+colorette@^1.2.1:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
+  integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
+
+commander@^2.20.0:
+  version "2.20.3"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
+  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
+
+commander@^6.2.0:
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c"
+  integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==
+
+commander@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-7.1.0.tgz#f2eaecf131f10e36e07d894698226e36ae0eb5ff"
+  integrity sha512-pRxBna3MJe6HKnBGsDyMv8ETbptw3axEdYHoqNh7gu5oDcew8fs0xnivZGm06Ogk8zGAJ9VX+OPEr2GXEQK4dg==
+
+core-util-is@~1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
+  integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
+
+cross-spawn@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
+  dependencies:
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
+
+csstype@^3.0.8:
+  version "3.0.8"
+  resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.0.8.tgz#d2266a792729fb227cd216fb572f43728e1ad340"
+  integrity sha512-jXKhWqXPmlUeoQnF/EhTtTl4C9SnrxSH/jZUih3jmO6lBKr99rP3/+FmrMj4EFpOXzMtXHAZkd3x0E6h6Fgflw==
+
+debug@^4.3.1:
+  version "4.3.1"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
+  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
+  dependencies:
+    ms "2.1.2"
+
+dompurify@^2.2.7:
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/dompurify/-/dompurify-2.2.7.tgz#a5f055a2a471638680e779bd08fc334962d11fd8"
+  integrity sha512-jdtDffdGNY+C76jvodNTu9jt5yYj59vuTUyx+wXdzcSwAGTYZDAQkQ7Iwx9zcGrA4ixC1syU4H3RZROqRxokxg==
+
+dot-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
+  integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
+  dependencies:
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+
+duplexer@^0.1.2:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
+  integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
+
+electron-to-chromium@^1.3.649:
+  version "1.3.680"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.680.tgz#88cc44bd2a85b46cf7521f714db57dd74d0cd488"
+  integrity sha512-XBACJT9RdpdWtoMXQPR8Be3ZtmizWWbxfw8cY2b5feUwiDO3FUl8qo4W2jXoq/WnnA3xBRqafu1XbpczqyUvlA==
+
+emojis-list@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
+  integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
+
+enhanced-resolve@^4.0.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec"
+  integrity sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==
+  dependencies:
+    graceful-fs "^4.1.2"
+    memory-fs "^0.5.0"
+    tapable "^1.0.0"
+
+enhanced-resolve@^5.7.0:
+  version "5.7.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.7.0.tgz#525c5d856680fbd5052de453ac83e32049958b5c"
+  integrity sha512-6njwt/NsZFUKhM6j9U8hzVyD4E4r0x7NQzhTCbcWOJ0IQjNSAoalWmb0AE51Wn+fwan5qVESWi7t2ToBxs9vrw==
+  dependencies:
+    graceful-fs "^4.2.4"
+    tapable "^2.2.0"
+
+enquirer@^2.3.6:
+  version "2.3.6"
+  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
+  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
+  dependencies:
+    ansi-colors "^4.1.1"
+
+envinfo@^7.7.3:
+  version "7.7.4"
+  resolved "https://registry.yarnpkg.com/envinfo/-/envinfo-7.7.4.tgz#c6311cdd38a0e86808c1c9343f667e4267c4a320"
+  integrity sha512-TQXTYFVVwwluWSFis6K2XKxgrD22jEv0FTuLCQI+OjH7rn93+iY0fSSFM5lrSxFY+H1+B0/cvvlamr3UsBivdQ==
+
+errno@^0.1.3:
+  version "0.1.8"
+  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
+  integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==
+  dependencies:
+    prr "~1.0.1"
+
+es-module-lexer@^0.4.0:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.4.1.tgz#dda8c6a14d8f340a24e34331e0fab0cb50438e0e"
+  integrity sha512-ooYciCUtfw6/d2w56UVeqHPcoCFAiJdz5XOkYpv/Txl1HMUozpXjz/2RIQgqwKdXNDPSF1W7mJCFse3G+HDyAA==
+
+escalade@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
+  integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
+
+eslint-scope@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
+  dependencies:
+    esrecurse "^4.3.0"
+    estraverse "^4.1.1"
+
+esrecurse@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
+  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
+  dependencies:
+    estraverse "^5.2.0"
+
+estraverse@^4.1.1:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
+  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
+
+estraverse@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.2.0.tgz#307df42547e6cc7324d3cf03c155d5cdb8c53880"
+  integrity sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==
+
+eventemitter3@^4.0.7:
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
+  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
+
+events@^3.2.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
+  integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
+
+execa@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.0.0.tgz#4029b0007998a841fbd1032e5f4de86a3c1e3376"
+  integrity sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==
+  dependencies:
+    cross-spawn "^7.0.3"
+    get-stream "^6.0.0"
+    human-signals "^2.1.0"
+    is-stream "^2.0.0"
+    merge-stream "^2.0.0"
+    npm-run-path "^4.0.1"
+    onetime "^5.1.2"
+    signal-exit "^3.0.3"
+    strip-final-newline "^2.0.0"
+
+fast-deep-equal@^3.1.1:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
+  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
+
+fast-json-stable-stringify@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
+  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
+
+fastest-levenshtein@^1.0.12:
+  version "1.0.12"
+  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.12.tgz#9990f7d3a88cc5a9ffd1f1745745251700d497e2"
+  integrity sha512-On2N+BpYJ15xIC974QNVuYGMOlEVt4s0EOI3wwMqOmK1fdDY+FN/zltPV8vosq4ad4c/gJ1KHScUn/6AWIgiow==
+
+fill-range@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
+  dependencies:
+    to-regex-range "^5.0.1"
+
+find-up@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
+  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
+  dependencies:
+    locate-path "^5.0.0"
+    path-exists "^4.0.0"
+
+function-bind@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
+
+get-stream@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.0.tgz#3e0012cb6827319da2706e601a1583e8629a6718"
+  integrity sha512-A1B3Bh1UmL0bidM/YX2NsCOTnGJePL9rO/M+Mw3m9f2gUpfokS0hi5Eah0WSUEWZdZhIZtMjkIYS7mDfOqNHbg==
+
+glob-to-regexp@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
+  integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
+
+graceful-fs@^4.1.2, graceful-fs@^4.2.4:
+  version "4.2.6"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
+  integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
+
+gzip-size@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/gzip-size/-/gzip-size-6.0.0.tgz#065367fd50c239c0671cbcbad5be3e2eeb10e462"
+  integrity sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==
+  dependencies:
+    duplexer "^0.1.2"
+
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
+has@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
+  dependencies:
+    function-bind "^1.1.1"
+
+human-signals@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
+  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
+
+import-local@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.0.2.tgz#a8cfd0431d1de4a2199703d003e3e62364fa6db6"
+  integrity sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==
+  dependencies:
+    pkg-dir "^4.2.0"
+    resolve-cwd "^3.0.0"
+
+inherits@2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
+  integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
+
+inherits@~2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+interpret@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/interpret/-/interpret-2.2.0.tgz#1a78a0b5965c40a5416d007ad6f50ad27c417df9"
+  integrity sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==
+
+is-core-module@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
+  integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
+  dependencies:
+    has "^1.0.3"
+
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
+is-plain-object@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+  integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
+  dependencies:
+    isobject "^3.0.1"
+
+is-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3"
+  integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==
+
+isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
+  integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
+
+isexe@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
+  integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
+
+isobject@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+  integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
+
+jest-worker@^26.6.2:
+  version "26.6.2"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-26.6.2.tgz#7f72cbc4d643c365e27b9fd775f9d0eaa9c7a8ed"
+  integrity sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==
+  dependencies:
+    "@types/node" "*"
+    merge-stream "^2.0.0"
+    supports-color "^7.0.0"
+
+json-parse-better-errors@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
+  integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
+
+json-schema-traverse@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
+  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
+
+json5@^2.1.2:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
+  integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
+  dependencies:
+    minimist "^1.2.5"
+
+kind-of@^6.0.2:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
+
+loader-runner@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.2.0.tgz#d7022380d66d14c5fb1d496b89864ebcfd478384"
+  integrity sha512-92+huvxMvYlMzMt0iIOukcwYBFpkYJdpl2xsZ7LrlayO7E8SOv+JJUEK17B/dJIHAOLMfh2dZZ/Y18WgmGtYNw==
+
+loader-utils@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.0.tgz#e4cace5b816d425a166b5f097e10cd12b36064b0"
+  integrity sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==
+  dependencies:
+    big.js "^5.2.2"
+    emojis-list "^3.0.0"
+    json5 "^2.1.2"
+
+locate-path@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
+  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
+  dependencies:
+    p-locate "^4.1.0"
+
+lodash@^4.17.20:
+  version "4.17.21"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+
+lower-case@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
+  integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
+  dependencies:
+    tslib "^2.0.3"
+
+lru-cache@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
+  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
+  dependencies:
+    yallist "^4.0.0"
+
+memory-fs@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
+  integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
+  dependencies:
+    errno "^0.1.3"
+    readable-stream "^2.0.1"
+
+merge-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
+  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
+
+micromatch@^4.0.0:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
+  integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
+  dependencies:
+    braces "^3.0.1"
+    picomatch "^2.0.5"
+
+mime-db@1.46.0:
+  version "1.46.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.46.0.tgz#6267748a7f799594de3cbc8cde91def349661cee"
+  integrity sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==
+
+mime-types@^2.1.27:
+  version "2.1.29"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.29.tgz#1d4ab77da64b91f5f72489df29236563754bb1b2"
+  integrity sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==
+  dependencies:
+    mime-db "1.46.0"
+
+mime@^2.3.1:
+  version "2.5.2"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-2.5.2.tgz#6e3dc6cc2b9510643830e5f19d5cb753da5eeabe"
+  integrity sha512-tqkh47FzKeCPD2PUiPB6pkbMzsCasjxAfC62/Wap5qrUWcb+sFasXUC5I3gYM5iBM8v/Qpn4UK0x+j0iHyFPDg==
+
+mimic-fn@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
+
+minimist@^1.2.5:
+  version "1.2.5"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
+  integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
+
+ms@2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
+neo-async@^2.6.2:
+  version "2.6.2"
+  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
+  integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
+
+no-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
+  integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
+  dependencies:
+    lower-case "^2.0.2"
+    tslib "^2.0.3"
+
+node-releases@^1.1.70:
+  version "1.1.71"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
+  integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
+
+npm-run-path@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
+  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
+  dependencies:
+    path-key "^3.0.0"
+
+onetime@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
+  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
+  dependencies:
+    mimic-fn "^2.1.0"
+
+opener@^1.5.2:
+  version "1.5.2"
+  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
+  integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
+
+p-limit@^2.2.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
+  dependencies:
+    p-try "^2.0.0"
+
+p-limit@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
+p-locate@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
+  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
+  dependencies:
+    p-limit "^2.2.0"
+
+p-try@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
+  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
+
+path-exists@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
+  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
+
+path-key@^3.0.0, path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
+
+path-parse@^1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
+  integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
+
+path@^0.12.7:
+  version "0.12.7"
+  resolved "https://registry.yarnpkg.com/path/-/path-0.12.7.tgz#d4dc2a506c4ce2197eb481ebfcd5b36c0140b10f"
+  integrity sha1-1NwqUGxM4hl+tIHr/NWzbAFAsQ8=
+  dependencies:
+    process "^0.11.1"
+    util "^0.10.3"
+
+picomatch@^2.0.5:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
+  integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
+
+pkg-dir@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
+  integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
+  dependencies:
+    find-up "^4.0.0"
+
+postmate@^1.5.2:
+  version "1.5.2"
+  resolved "https://registry.yarnpkg.com/postmate/-/postmate-1.5.2.tgz#d59a78b3780023c5d32225fd40633b364958bdb3"
+  integrity sha512-EHLlEmrUA/hALls49oBrtE7BzDXXjB9EiO4MZpsoO3R/jRuBmD+2WKQuYAbeuVEpTzrPpUTT79z2cz4qaFgPRg==
+
+process-nextick-args@~2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
+  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
+
+process@^0.11.1:
+  version "0.11.10"
+  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
+  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
+
+prr@~1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
+  integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY=
+
+punycode@^2.1.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
+  integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
+
+randombytes@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
+  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
+  dependencies:
+    safe-buffer "^5.1.0"
+
+readable-stream@^2.0.1:
+  version "2.3.7"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
+  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+rechoir@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.7.0.tgz#32650fd52c21ab252aa5d65b19310441c7e03aca"
+  integrity sha512-ADsDEH2bvbjltXEP+hTIAmeFekTFK0V2BTxMkok6qILyAJEXV0AFfoWcAq4yfll5VdIMd/RVXq0lR+wQi5ZU3Q==
+  dependencies:
+    resolve "^1.9.0"
+
+resolve-cwd@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d"
+  integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==
+  dependencies:
+    resolve-from "^5.0.0"
+
+resolve-from@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
+  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
+
+resolve@^1.9.0:
+  version "1.20.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
+  integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
+  dependencies:
+    is-core-module "^2.2.0"
+    path-parse "^1.0.6"
+
+safe-buffer@^5.1.0:
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+schema-utils@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.0.0.tgz#67502f6aa2b66a2d4032b4279a2944978a0913ef"
+  integrity sha512-6D82/xSzO094ajanoOSbe4YvXWMfn2A//8Y1+MUqFAJul5Bs+yn36xbK9OtNDcRVSBJ9jjeoXftM6CfztsjOAA==
+  dependencies:
+    "@types/json-schema" "^7.0.6"
+    ajv "^6.12.5"
+    ajv-keywords "^3.5.2"
+
+semver@^7.3.4:
+  version "7.3.4"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.4.tgz#27aaa7d2e4ca76452f98d3add093a72c943edc97"
+  integrity sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==
+  dependencies:
+    lru-cache "^6.0.0"
+
+serialize-javascript@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-5.0.1.tgz#7886ec848049a462467a97d3d918ebb2aaf934f4"
+  integrity sha512-SaaNal9imEO737H2c05Og0/8LUXG7EnsZyMa8MzkmuHoELfT6txuj0cMqRj6zfPKnmQ1yasR4PCJc8x+M4JSPA==
+  dependencies:
+    randombytes "^2.1.0"
+
+shallow-clone@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
+  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
+  dependencies:
+    kind-of "^6.0.2"
+
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
+  dependencies:
+    shebang-regex "^3.0.0"
+
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
+
+signal-exit@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c"
+  integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==
+
+sirv@^1.0.7:
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/sirv/-/sirv-1.0.11.tgz#81c19a29202048507d6ec0d8ba8910fda52eb5a4"
+  integrity sha512-SR36i3/LSWja7AJNRBz4fF/Xjpn7lQFI30tZ434dIy+bitLYSP+ZEenHg36i23V2SGEz+kqjksg0uOGZ5LPiqg==
+  dependencies:
+    "@polka/url" "^1.0.0-next.9"
+    mime "^2.3.1"
+    totalist "^1.0.0"
+
+snake-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c"
+  integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
+  dependencies:
+    dot-case "^3.0.4"
+    tslib "^2.0.3"
+
+source-list-map@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-2.0.1.tgz#3993bd873bfc48479cca9ea3a547835c7c154b34"
+  integrity sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==
+
+source-map-support@~0.5.19:
+  version "0.5.19"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
+  integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map@^0.6.0, source-map@^0.6.1:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+source-map@~0.7.2:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
+
+string_decoder@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
+strip-final-newline@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
+  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
+
+supports-color@^7.0.0, supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
+tapable@^1.0.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-1.1.3.tgz#a1fccc06b58db61fd7a45da2da44f5f3a3e67ba2"
+  integrity sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==
+
+tapable@^2.1.1, tapable@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.0.tgz#5c373d281d9c672848213d0e037d1c4165ab426b"
+  integrity sha512-FBk4IesMV1rBxX2tfiK8RAmogtWn53puLOQlvO8XuwlgxcYbP4mVPS9Ph4aeamSyyVjOl24aYWAuc8U5kCVwMw==
+
+terser-webpack-plugin@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.1.1.tgz#7effadee06f7ecfa093dbbd3e9ab23f5f3ed8673"
+  integrity sha512-5XNNXZiR8YO6X6KhSGXfY0QrGrCRlSwAEjIIrlRQR4W8nP69TaJUlh3bkuac6zzgspiGPfKEHcY295MMVExl5Q==
+  dependencies:
+    jest-worker "^26.6.2"
+    p-limit "^3.1.0"
+    schema-utils "^3.0.0"
+    serialize-javascript "^5.0.1"
+    source-map "^0.6.1"
+    terser "^5.5.1"
+
+terser@^5.5.1:
+  version "5.6.0"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.6.0.tgz#138cdf21c5e3100b1b3ddfddf720962f88badcd2"
+  integrity sha512-vyqLMoqadC1uR0vywqOZzriDYzgEkNJFK4q9GeyOBHIbiECHiWLKcWfbQWAUaPfxkjDhapSlZB9f7fkMrvkVjA==
+  dependencies:
+    commander "^2.20.0"
+    source-map "~0.7.2"
+    source-map-support "~0.5.19"
+
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
+totalist@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/totalist/-/totalist-1.1.0.tgz#a4d65a3e546517701e3e5c37a47a70ac97fe56df"
+  integrity sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g==
+
+ts-loader@^8.0.17:
+  version "8.0.17"
+  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-8.0.17.tgz#98f2ccff9130074f4079fd89b946b4c637b1f2fc"
+  integrity sha512-OeVfSshx6ot/TCxRwpBHQ/4lRzfgyTkvi7ghDVrLXOHzTbSK413ROgu/xNqM72i3AFeAIJgQy78FwSMKmOW68w==
+  dependencies:
+    chalk "^4.1.0"
+    enhanced-resolve "^4.0.0"
+    loader-utils "^2.0.0"
+    micromatch "^4.0.0"
+    semver "^7.3.4"
+
+tslib@^1.9.0:
+  version "1.14.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
+  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
+
+tslib@^2.0.3:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
+  integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
+
+typescript@^4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.2.tgz#1450f020618f872db0ea17317d16d8da8ddb8c4c"
+  integrity sha512-tbb+NVrLfnsJy3M59lsDgrzWIflR4d4TIUjz+heUnHZwdF7YsrMTKoRERiIvI2lvBG95dfpLxB21WZhys1bgaQ==
+
+uri-js@^4.2.2:
+  version "4.4.1"
+  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
+  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
+  dependencies:
+    punycode "^2.1.0"
+
+util-deprecate@~1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+  integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
+
+util@^0.10.3:
+  version "0.10.4"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.10.4.tgz#3aa0125bfe668a4672de58857d3ace27ecb76901"
+  integrity sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==
+  dependencies:
+    inherits "2.0.3"
+
+v8-compile-cache@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.2.0.tgz#9471efa3ef9128d2f7c6a7ca39c4dd6b5055b132"
+  integrity sha512-gTpR5XQNKFwOd4clxfnhaqvfqMpqEwr4tOtCyz4MtYZX2JYhfr1JvBFKdS+7K/9rfpZR3VLX+YWBbKoxCgS43Q==
+
+watchpack@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.1.1.tgz#e99630550fca07df9f90a06056987baa40a689c7"
+  integrity sha512-Oo7LXCmc1eE1AjyuSBmtC3+Wy4HcV8PxWh2kP6fOl8yTlNS7r0K9l1ao2lrrUza7V39Y3D/BbJgY8VeSlc5JKw==
+  dependencies:
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.1.2"
+
+webpack-bundle-analyzer@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.4.0.tgz#74013106e7e2b07cbd64f3a5ae847f7e814802c7"
+  integrity sha512-9DhNa+aXpqdHk8LkLPTBU/dMfl84Y+WE2+KnfI6rSpNRNVKa0VGLjPd2pjFubDeqnWmulFggxmWBxhfJXZnR0g==
+  dependencies:
+    acorn "^8.0.4"
+    acorn-walk "^8.0.0"
+    chalk "^4.1.0"
+    commander "^6.2.0"
+    gzip-size "^6.0.0"
+    lodash "^4.17.20"
+    opener "^1.5.2"
+    sirv "^1.0.7"
+    ws "^7.3.1"
+
+webpack-cli@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-4.5.0.tgz#b5213b84adf6e1f5de6391334c9fa53a48850466"
+  integrity sha512-wXg/ef6Ibstl2f50mnkcHblRPN/P9J4Nlod5Hg9HGFgSeF8rsqDGHJeVe4aR26q9l62TUJi6vmvC2Qz96YJw1Q==
+  dependencies:
+    "@discoveryjs/json-ext" "^0.5.0"
+    "@webpack-cli/configtest" "^1.0.1"
+    "@webpack-cli/info" "^1.2.2"
+    "@webpack-cli/serve" "^1.3.0"
+    colorette "^1.2.1"
+    commander "^7.0.0"
+    enquirer "^2.3.6"
+    execa "^5.0.0"
+    fastest-levenshtein "^1.0.12"
+    import-local "^3.0.2"
+    interpret "^2.2.0"
+    rechoir "^0.7.0"
+    v8-compile-cache "^2.2.0"
+    webpack-merge "^5.7.3"
+
+webpack-merge@^5.7.3:
+  version "5.7.3"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-5.7.3.tgz#2a0754e1877a25a8bbab3d2475ca70a052708213"
+  integrity sha512-6/JUQv0ELQ1igjGDzHkXbVDRxkfA57Zw7PfiupdLFJYrgFqY5ZP8xxbpp2lU3EPwYx89ht5Z/aDkD40hFCm5AA==
+  dependencies:
+    clone-deep "^4.0.1"
+    wildcard "^2.0.0"
+
+webpack-sources@^2.1.1:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-2.2.0.tgz#058926f39e3d443193b6c31547229806ffd02bac"
+  integrity sha512-bQsA24JLwcnWGArOKUxYKhX3Mz/nK1Xf6hxullKERyktjNMC4x8koOeaDNTA2fEJ09BdWLbM/iTW0ithREUP0w==
+  dependencies:
+    source-list-map "^2.0.1"
+    source-map "^0.6.1"
+
+webpack@^5.24.3:
+  version "5.24.3"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.24.3.tgz#6ec0f5059f8d7c7961075fa553cfce7b7928acb3"
+  integrity sha512-x7lrWZ7wlWAdyKdML6YPvfVZkhD1ICuIZGODE5SzKJjqI9A4SpqGTjGJTc6CwaHqn19gGaoOR3ONJ46nYsn9rw==
+  dependencies:
+    "@types/eslint-scope" "^3.7.0"
+    "@types/estree" "^0.0.46"
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/wasm-edit" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
+    acorn "^8.0.4"
+    browserslist "^4.14.5"
+    chrome-trace-event "^1.0.2"
+    enhanced-resolve "^5.7.0"
+    es-module-lexer "^0.4.0"
+    eslint-scope "^5.1.1"
+    events "^3.2.0"
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.2.4"
+    json-parse-better-errors "^1.0.2"
+    loader-runner "^4.2.0"
+    mime-types "^2.1.27"
+    neo-async "^2.6.2"
+    schema-utils "^3.0.0"
+    tapable "^2.1.1"
+    terser-webpack-plugin "^5.1.1"
+    watchpack "^2.0.0"
+    webpack-sources "^2.1.1"
+
+which@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
+  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
+  dependencies:
+    isexe "^2.0.0"
+
+wildcard@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/wildcard/-/wildcard-2.0.0.tgz#a77d20e5200c6faaac979e4b3aadc7b3dd7f8fec"
+  integrity sha512-JcKqAHLPxcdb9KM49dufGXn2x3ssnfjbcaQdLlfZsL9rH9wgDQjUtDxbo8NE0F6SFvydeu1VhZe7hZuHsB2/pw==
+
+ws@^7.3.1:
+  version "7.4.4"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.4.tgz#383bc9742cb202292c9077ceab6f6047b17f2d59"
+  integrity sha512-Qm8k8ojNQIMx7S+Zp8u/uHOx7Qazv3Yv4q68MiWWWOJhiwG5W3x7iqmRtJo8xxrciZUY4vRxUTJCKuRnF28ZZw==
+
+yallist@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
+  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
+
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
diff --git a/resources/electron-dev.html b/resources/electron-dev.html
index f907b77807..f7d30c82cf 100644
--- a/resources/electron-dev.html
+++ b/resources/electron-dev.html
@@ -30,6 +30,7 @@
 </head>
 <body>
 <div id="root"></div>
+<script>window.__LSP__HOST__ = true</script>
 <script>window.user = null</script>
 <script src="./js/magic_portal.js"></script>
 <script>let worker = new Worker('./js/worker.js')
@@ -49,6 +50,7 @@ const portal = new MagicPortal(worker);
 </script>
 <script defer src="./js/highlight.min.js"></script>
 <script defer src="./js/interact.min.js"></script>
+<script defer src="./js/lsplugin.core.js"></script>
 <script defer src="./js/main.js"></script>
 <script defer src="./js/code-editor.js"></script>
 <script defer src="./js/age-encryption.js"></script>
diff --git a/resources/electron.html b/resources/electron.html
index fa9605fad7..70d5ae5286 100644
--- a/resources/electron.html
+++ b/resources/electron.html
@@ -30,6 +30,7 @@
 </head>
 <body>
 <div id="root"></div>
+<script>window.__LSP__HOST__ = true</script>
 <script>window.user = null</script>
 <script src="./js/magic_portal.js"></script>
 <script>let worker = new Worker('./js/worker.js')
@@ -49,6 +50,7 @@ const portal = new MagicPortal(worker);
 </script>
 <script defer src="./js/highlight.min.js"></script>
 <script defer src="./js/interact.min.js"></script>
+<script defer src="./js/lsplugin.core.js"></script>
 <script defer src="./js/main.js"></script>
 <script defer src="./js/code-editor.js"></script>
 <script defer src="./js/age-encryption.js"></script>
diff --git a/resources/js/lsplugin.core.js b/resources/js/lsplugin.core.js
new file mode 100644
index 0000000000..29e335869d
--- /dev/null
+++ b/resources/js/lsplugin.core.js
@@ -0,0 +1,6617 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["LSPlugin"] = factory();
+	else
+		root["LSPlugin"] = factory();
+})(self, function() {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./node_modules/debug/src/browser.js":
+/*!*******************************************!*\
+  !*** ./node_modules/debug/src/browser.js ***!
+  \*******************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = (() => {
+	let warned = false;
+
+	return () => {
+		if (!warned) {
+			warned = true;
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+	};
+})();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+	'#0000CC',
+	'#0000FF',
+	'#0033CC',
+	'#0033FF',
+	'#0066CC',
+	'#0066FF',
+	'#0099CC',
+	'#0099FF',
+	'#00CC00',
+	'#00CC33',
+	'#00CC66',
+	'#00CC99',
+	'#00CCCC',
+	'#00CCFF',
+	'#3300CC',
+	'#3300FF',
+	'#3333CC',
+	'#3333FF',
+	'#3366CC',
+	'#3366FF',
+	'#3399CC',
+	'#3399FF',
+	'#33CC00',
+	'#33CC33',
+	'#33CC66',
+	'#33CC99',
+	'#33CCCC',
+	'#33CCFF',
+	'#6600CC',
+	'#6600FF',
+	'#6633CC',
+	'#6633FF',
+	'#66CC00',
+	'#66CC33',
+	'#9900CC',
+	'#9900FF',
+	'#9933CC',
+	'#9933FF',
+	'#99CC00',
+	'#99CC33',
+	'#CC0000',
+	'#CC0033',
+	'#CC0066',
+	'#CC0099',
+	'#CC00CC',
+	'#CC00FF',
+	'#CC3300',
+	'#CC3333',
+	'#CC3366',
+	'#CC3399',
+	'#CC33CC',
+	'#CC33FF',
+	'#CC6600',
+	'#CC6633',
+	'#CC9900',
+	'#CC9933',
+	'#CCCC00',
+	'#CCCC33',
+	'#FF0000',
+	'#FF0033',
+	'#FF0066',
+	'#FF0099',
+	'#FF00CC',
+	'#FF00FF',
+	'#FF3300',
+	'#FF3333',
+	'#FF3366',
+	'#FF3399',
+	'#FF33CC',
+	'#FF33FF',
+	'#FF6600',
+	'#FF6633',
+	'#FF9900',
+	'#FF9933',
+	'#FFCC00',
+	'#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+// eslint-disable-next-line complexity
+function useColors() {
+	// NB: In an Electron preload script, document will be defined but not fully
+	// initialized. Since we know we're in Chrome, we'll just detect this case
+	// explicitly
+	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+		return true;
+	}
+
+	// Internet Explorer and Edge do not support colors.
+	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		return false;
+	}
+
+	// Is webkit? http://stackoverflow.com/a/16459606/376773
+	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+		// Is firebug? http://stackoverflow.com/a/398120/376773
+		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+		// Is firefox >= v31?
+		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+		// Double check webkit in userAgent just in case we are in a worker
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+	args[0] = (this.useColors ? '%c' : '') +
+		this.namespace +
+		(this.useColors ? ' %c' : ' ') +
+		args[0] +
+		(this.useColors ? '%c ' : ' ') +
+		'+' + module.exports.humanize(this.diff);
+
+	if (!this.useColors) {
+		return;
+	}
+
+	const c = 'color: ' + this.color;
+	args.splice(1, 0, c, 'color: inherit');
+
+	// The final "%c" is somewhat tricky, because there could be other
+	// arguments passed either before or after the %c, so we need to
+	// figure out the correct index to insert the CSS into
+	let index = 0;
+	let lastC = 0;
+	args[0].replace(/%[a-zA-Z%]/g, match => {
+		if (match === '%%') {
+			return;
+		}
+		index++;
+		if (match === '%c') {
+			// We only are interested in the *last* %c
+			// (the user may have provided their own)
+			lastC = index;
+		}
+	});
+
+	args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */
+exports.log = console.debug || console.log || (() => {});
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	try {
+		if (namespaces) {
+			exports.storage.setItem('debug', namespaces);
+		} else {
+			exports.storage.removeItem('debug');
+		}
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+function load() {
+	let r;
+	try {
+		r = exports.storage.getItem('debug');
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+
+	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+	if (!r && typeof process !== 'undefined' && 'env' in process) {
+		r = process.env.DEBUG;
+	}
+
+	return r;
+}
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+	try {
+		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+		// The Browser also has localStorage in the global context.
+		return localStorage;
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+module.exports = __webpack_require__(/*! ./common */ "./node_modules/debug/src/common.js")(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+	try {
+		return JSON.stringify(v);
+	} catch (error) {
+		return '[UnexpectedJSONParseError]: ' + error.message;
+	}
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/debug/src/common.js":
+/*!******************************************!*\
+  !*** ./node_modules/debug/src/common.js ***!
+  \******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = __webpack_require__(/*! ms */ "./node_modules/ms/index.js");
+	createDebug.destroy = destroy;
+
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
+
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+
+	createDebug.names = [];
+	createDebug.skips = [];
+
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
+
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
+
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	}
+	createDebug.selectColor = selectColor;
+
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
+
+			const self = debug;
+
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
+
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
+	}
+
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		let i;
+		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		const len = split.length;
+
+		for (i = 0; i < len; i++) {
+			if (!split[i]) {
+				// ignore empty strings
+				continue;
+			}
+
+			namespaces = split[i].replace(/\*/g, '.*?');
+
+			if (namespaces[0] === '-') {
+				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+			} else {
+				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+			}
+		}
+	}
+
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names.map(toNamespace),
+			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
+
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		if (name[name.length - 1] === '*') {
+			return true;
+		}
+
+		let i;
+		let len;
+
+		for (i = 0, len = createDebug.skips.length; i < len; i++) {
+			if (createDebug.skips[i].test(name)) {
+				return false;
+			}
+		}
+
+		for (i = 0, len = createDebug.names.length; i < len; i++) {
+			if (createDebug.names[i].test(name)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	* Convert regexp to namespace
+	*
+	* @param {RegExp} regxep
+	* @return {String} namespace
+	* @api private
+	*/
+	function toNamespace(regexp) {
+		return regexp.toString()
+			.substring(2, regexp.toString().length - 2)
+			.replace(/\.\*\?$/, '*');
+	}
+
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
+		}
+		return val;
+	}
+
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
+
+	createDebug.enable(createDebug.load());
+
+	return createDebug;
+}
+
+module.exports = setup;
+
+
+/***/ }),
+
+/***/ "./node_modules/dompurify/dist/purify.js":
+/*!***********************************************!*\
+  !*** ./node_modules/dompurify/dist/purify.js ***!
+  \***********************************************/
+/***/ (function(module) {
+
+/*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */
+
+(function (global, factory) {
+   true ? module.exports = factory() :
+  0;
+}(this, function () { 'use strict';
+
+  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  var hasOwnProperty = Object.hasOwnProperty,
+      setPrototypeOf = Object.setPrototypeOf,
+      isFrozen = Object.isFrozen,
+      getPrototypeOf = Object.getPrototypeOf,
+      getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var freeze = Object.freeze,
+      seal = Object.seal,
+      create = Object.create; // eslint-disable-line import/no-mutable-exports
+
+  var _ref = typeof Reflect !== 'undefined' && Reflect,
+      apply = _ref.apply,
+      construct = _ref.construct;
+
+  if (!apply) {
+    apply = function apply(fun, thisValue, args) {
+      return fun.apply(thisValue, args);
+    };
+  }
+
+  if (!freeze) {
+    freeze = function freeze(x) {
+      return x;
+    };
+  }
+
+  if (!seal) {
+    seal = function seal(x) {
+      return x;
+    };
+  }
+
+  if (!construct) {
+    construct = function construct(Func, args) {
+      return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))();
+    };
+  }
+
+  var arrayForEach = unapply(Array.prototype.forEach);
+  var arrayPop = unapply(Array.prototype.pop);
+  var arrayPush = unapply(Array.prototype.push);
+
+  var stringToLowerCase = unapply(String.prototype.toLowerCase);
+  var stringMatch = unapply(String.prototype.match);
+  var stringReplace = unapply(String.prototype.replace);
+  var stringIndexOf = unapply(String.prototype.indexOf);
+  var stringTrim = unapply(String.prototype.trim);
+
+  var regExpTest = unapply(RegExp.prototype.test);
+
+  var typeErrorCreate = unconstruct(TypeError);
+
+  function unapply(func) {
+    return function (thisArg) {
+      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      return apply(func, thisArg, args);
+    };
+  }
+
+  function unconstruct(func) {
+    return function () {
+      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      return construct(func, args);
+    };
+  }
+
+  /* Add properties to a lookup table */
+  function addToSet(set, array) {
+    if (setPrototypeOf) {
+      // Make 'in' and truthy checks like Boolean(set.constructor)
+      // independent of any properties defined on Object.prototype.
+      // Prevent prototype setters from intercepting set as a this value.
+      setPrototypeOf(set, null);
+    }
+
+    var l = array.length;
+    while (l--) {
+      var element = array[l];
+      if (typeof element === 'string') {
+        var lcElement = stringToLowerCase(element);
+        if (lcElement !== element) {
+          // Config presets (e.g. tags.js, attrs.js) are immutable.
+          if (!isFrozen(array)) {
+            array[l] = lcElement;
+          }
+
+          element = lcElement;
+        }
+      }
+
+      set[element] = true;
+    }
+
+    return set;
+  }
+
+  /* Shallow clone an object */
+  function clone(object) {
+    var newObject = create(null);
+
+    var property = void 0;
+    for (property in object) {
+      if (apply(hasOwnProperty, object, [property])) {
+        newObject[property] = object[property];
+      }
+    }
+
+    return newObject;
+  }
+
+  /* IE10 doesn't support __lookupGetter__ so lets'
+   * simulate it. It also automatically checks
+   * if the prop is function or getter and behaves
+   * accordingly. */
+  function lookupGetter(object, prop) {
+    while (object !== null) {
+      var desc = getOwnPropertyDescriptor(object, prop);
+      if (desc) {
+        if (desc.get) {
+          return unapply(desc.get);
+        }
+
+        if (typeof desc.value === 'function') {
+          return unapply(desc.value);
+        }
+      }
+
+      object = getPrototypeOf(object);
+    }
+
+    function fallbackValue(element) {
+      console.warn('fallback value for', element);
+      return null;
+    }
+
+    return fallbackValue;
+  }
+
+  var html = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
+
+  // SVG
+  var svg = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
+
+  var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
+
+  // List of SVG elements that are disallowed by default.
+  // We still need to know them so that we can do namespace
+  // checks properly in case one wants to add them to
+  // allow-list.
+  var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
+
+  var mathMl = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']);
+
+  // Similarly to SVG, we want to know all MathML elements,
+  // even those that we disallow by default.
+  var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
+
+  var text = freeze(['#text']);
+
+  var html$1 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns']);
+
+  var svg$1 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+
+  var mathMl$1 = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
+
+  var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
+
+  // eslint-disable-next-line unicorn/better-regex
+  var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+  var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm);
+  var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); // eslint-disable-line no-useless-escape
+  var ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
+  var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
+  );
+  var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+  var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
+  );
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+  function _toConsumableArray$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  var getGlobal = function getGlobal() {
+    return typeof window === 'undefined' ? null : window;
+  };
+
+  /**
+   * Creates a no-op policy for internal use only.
+   * Don't export this function outside this module!
+   * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.
+   * @param {Document} document The document object (to determine policy name suffix)
+   * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types
+   * are not supported).
+   */
+  var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {
+    if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+      return null;
+    }
+
+    // Allow the callers to control the unique policy name
+    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+    // Policy creation with duplicate names throws in Trusted Types.
+    var suffix = null;
+    var ATTR_NAME = 'data-tt-policy-suffix';
+    if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {
+      suffix = document.currentScript.getAttribute(ATTR_NAME);
+    }
+
+    var policyName = 'dompurify' + (suffix ? '#' + suffix : '');
+
+    try {
+      return trustedTypes.createPolicy(policyName, {
+        createHTML: function createHTML(html$$1) {
+          return html$$1;
+        }
+      });
+    } catch (_) {
+      // Policy creation failed (most likely another DOMPurify script has
+      // already run). Skip creating the policy, as this will only cause errors
+      // if TT are enforced.
+      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
+      return null;
+    }
+  };
+
+  function createDOMPurify() {
+    var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
+
+    var DOMPurify = function DOMPurify(root) {
+      return createDOMPurify(root);
+    };
+
+    /**
+     * Version label, exposed for easier checks
+     * if DOMPurify is up to date or not
+     */
+    DOMPurify.version = '2.2.7';
+
+    /**
+     * Array of elements that DOMPurify removed during sanitation.
+     * Empty if nothing was removed.
+     */
+    DOMPurify.removed = [];
+
+    if (!window || !window.document || window.document.nodeType !== 9) {
+      // Not running in a browser, provide a factory function
+      // so that you can pass your own Window
+      DOMPurify.isSupported = false;
+
+      return DOMPurify;
+    }
+
+    var originalDocument = window.document;
+
+    var document = window.document;
+    var DocumentFragment = window.DocumentFragment,
+        HTMLTemplateElement = window.HTMLTemplateElement,
+        Node = window.Node,
+        Element = window.Element,
+        NodeFilter = window.NodeFilter,
+        _window$NamedNodeMap = window.NamedNodeMap,
+        NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,
+        Text = window.Text,
+        Comment = window.Comment,
+        DOMParser = window.DOMParser,
+        trustedTypes = window.trustedTypes;
+
+
+    var ElementPrototype = Element.prototype;
+
+    var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+    var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
+    var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
+    var getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+
+    // As per issue #47, the web-components registry is inherited by a
+    // new document created via createHTMLDocument. As per the spec
+    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+    // a new empty registry is used when creating a template contents owner
+    // document, so we use that as our parent document to ensure nothing
+    // is inherited.
+    if (typeof HTMLTemplateElement === 'function') {
+      var template = document.createElement('template');
+      if (template.content && template.content.ownerDocument) {
+        document = template.content.ownerDocument;
+      }
+    }
+
+    var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
+    var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : '';
+
+    var _document = document,
+        implementation = _document.implementation,
+        createNodeIterator = _document.createNodeIterator,
+        getElementsByTagName = _document.getElementsByTagName,
+        createDocumentFragment = _document.createDocumentFragment;
+    var importNode = originalDocument.importNode;
+
+
+    var documentMode = {};
+    try {
+      documentMode = clone(document).documentMode ? document.documentMode : {};
+    } catch (_) {}
+
+    var hooks = {};
+
+    /**
+     * Expose whether this browser supports running the full DOMPurify.
+     */
+    DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;
+
+    var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR,
+        ERB_EXPR$$1 = ERB_EXPR,
+        DATA_ATTR$$1 = DATA_ATTR,
+        ARIA_ATTR$$1 = ARIA_ATTR,
+        IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA,
+        ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;
+    var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;
+
+    /**
+     * We consider the elements and attributes below to be safe. Ideally
+     * don't add any new ones but feel free to remove unwanted ones.
+     */
+
+    /* allowed element names */
+
+    var ALLOWED_TAGS = null;
+    var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));
+
+    /* Allowed attribute names */
+    var ALLOWED_ATTR = null;
+    var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));
+
+    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
+    var FORBID_TAGS = null;
+
+    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
+    var FORBID_ATTR = null;
+
+    /* Decide if ARIA attributes are okay */
+    var ALLOW_ARIA_ATTR = true;
+
+    /* Decide if custom data attributes are okay */
+    var ALLOW_DATA_ATTR = true;
+
+    /* Decide if unknown protocols are okay */
+    var ALLOW_UNKNOWN_PROTOCOLS = false;
+
+    /* Output should be safe for common template engines.
+     * This means, DOMPurify removes data attributes, mustaches and ERB
+     */
+    var SAFE_FOR_TEMPLATES = false;
+
+    /* Decide if document with <html>... should be returned */
+    var WHOLE_DOCUMENT = false;
+
+    /* Track whether config is already set on this instance of DOMPurify. */
+    var SET_CONFIG = false;
+
+    /* Decide if all elements (e.g. style, script) must be children of
+     * document.body. By default, browsers might move them to document.head */
+    var FORCE_BODY = false;
+
+    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+     * string (or a TrustedHTML object if Trusted Types are supported).
+     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+     */
+    var RETURN_DOM = false;
+
+    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+     * string  (or a TrustedHTML object if Trusted Types are supported) */
+    var RETURN_DOM_FRAGMENT = false;
+
+    /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM
+     * `Node` is imported into the current `Document`. If this flag is not enabled the
+     * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by
+     * DOMPurify.
+     *
+     * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`
+     * might cause XSS from attacks hidden in closed shadowroots in case the browser
+     * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/
+     */
+    var RETURN_DOM_IMPORT = true;
+
+    /* Try to return a Trusted Type object instead of a string, return a string in
+     * case Trusted Types are not supported  */
+    var RETURN_TRUSTED_TYPE = false;
+
+    /* Output should be free from DOM clobbering attacks? */
+    var SANITIZE_DOM = true;
+
+    /* Keep element content when removing element? */
+    var KEEP_CONTENT = true;
+
+    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+     * of importing it into a new Document and returning a sanitized copy */
+    var IN_PLACE = false;
+
+    /* Allow usage of profiles like html, svg and mathMl */
+    var USE_PROFILES = {};
+
+    /* Tags to ignore content of when KEEP_CONTENT is true */
+    var FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
+
+    /* Tags that are safe for data: URIs */
+    var DATA_URI_TAGS = null;
+    var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
+
+    /* Attributes safe for values like "javascript:" */
+    var URI_SAFE_ATTRIBUTES = null;
+    var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'summary', 'title', 'value', 'style', 'xmlns']);
+
+    /* Keep a reference to config to pass to hooks */
+    var CONFIG = null;
+
+    /* Ideally, do not touch anything below this line */
+    /* ______________________________________________ */
+
+    var formElement = document.createElement('form');
+
+    /**
+     * _parseConfig
+     *
+     * @param  {Object} cfg optional config literal
+     */
+    // eslint-disable-next-line complexity
+    var _parseConfig = function _parseConfig(cfg) {
+      if (CONFIG && CONFIG === cfg) {
+        return;
+      }
+
+      /* Shield configuration object from tampering */
+      if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof(cfg)) !== 'object') {
+        cfg = {};
+      }
+
+      /* Shield configuration object from prototype pollution */
+      cfg = clone(cfg);
+
+      /* Set configuration parameters */
+      ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
+      ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
+      URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
+      DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
+      FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
+      FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
+      USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
+      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
+      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
+      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
+      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
+      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
+      RETURN_DOM = cfg.RETURN_DOM || false; // Default false
+      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
+      RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true
+      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
+      FORCE_BODY = cfg.FORCE_BODY || false; // Default false
+      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
+      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
+      IN_PLACE = cfg.IN_PLACE || false; // Default false
+      IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;
+      if (SAFE_FOR_TEMPLATES) {
+        ALLOW_DATA_ATTR = false;
+      }
+
+      if (RETURN_DOM_FRAGMENT) {
+        RETURN_DOM = true;
+      }
+
+      /* Parse profile info */
+      if (USE_PROFILES) {
+        ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));
+        ALLOWED_ATTR = [];
+        if (USE_PROFILES.html === true) {
+          addToSet(ALLOWED_TAGS, html);
+          addToSet(ALLOWED_ATTR, html$1);
+        }
+
+        if (USE_PROFILES.svg === true) {
+          addToSet(ALLOWED_TAGS, svg);
+          addToSet(ALLOWED_ATTR, svg$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+
+        if (USE_PROFILES.svgFilters === true) {
+          addToSet(ALLOWED_TAGS, svgFilters);
+          addToSet(ALLOWED_ATTR, svg$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+
+        if (USE_PROFILES.mathMl === true) {
+          addToSet(ALLOWED_TAGS, mathMl);
+          addToSet(ALLOWED_ATTR, mathMl$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+      }
+
+      /* Merge configuration parameters */
+      if (cfg.ADD_TAGS) {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
+      }
+
+      if (cfg.ADD_ATTR) {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
+      }
+
+      if (cfg.ADD_URI_SAFE_ATTR) {
+        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
+      }
+
+      /* Add #text in case KEEP_CONTENT is set to true */
+      if (KEEP_CONTENT) {
+        ALLOWED_TAGS['#text'] = true;
+      }
+
+      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
+      if (WHOLE_DOCUMENT) {
+        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
+      }
+
+      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
+      if (ALLOWED_TAGS.table) {
+        addToSet(ALLOWED_TAGS, ['tbody']);
+        delete FORBID_TAGS.tbody;
+      }
+
+      // Prevent further manipulation of configuration.
+      // Not available in IE8, Safari 5, etc.
+      if (freeze) {
+        freeze(cfg);
+      }
+
+      CONFIG = cfg;
+    };
+
+    var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
+
+    var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']);
+
+    /* Keep track of all possible SVG and MathML tags
+     * so that we can perform the namespace checks
+     * correctly. */
+    var ALL_SVG_TAGS = addToSet({}, svg);
+    addToSet(ALL_SVG_TAGS, svgFilters);
+    addToSet(ALL_SVG_TAGS, svgDisallowed);
+
+    var ALL_MATHML_TAGS = addToSet({}, mathMl);
+    addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+
+    var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+    var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+    var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+
+    /**
+     *
+     *
+     * @param  {Element} element a DOM element whose namespace is being checked
+     * @returns {boolean} Return false if the element has a
+     *  namespace that a spec-compliant parser would never
+     *  return. Return true otherwise.
+     */
+    var _checkValidNamespace = function _checkValidNamespace(element) {
+      var parent = getParentNode(element);
+
+      // In JSDOM, if we're inside shadow DOM, then parentNode
+      // can be null. We just simulate parent in this case.
+      if (!parent || !parent.tagName) {
+        parent = {
+          namespaceURI: HTML_NAMESPACE,
+          tagName: 'template'
+        };
+      }
+
+      var tagName = stringToLowerCase(element.tagName);
+      var parentTagName = stringToLowerCase(parent.tagName);
+
+      if (element.namespaceURI === SVG_NAMESPACE) {
+        // The only way to switch from HTML namespace to SVG
+        // is via <svg>. If it happens via any other tag, then
+        // it should be killed.
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === 'svg';
+        }
+
+        // The only way to switch from MathML to SVG is via
+        // svg if parent is either <annotation-xml> or MathML
+        // text integration points.
+        if (parent.namespaceURI === MATHML_NAMESPACE) {
+          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+        }
+
+        // We only allow elements that are defined in SVG
+        // spec. All others are disallowed in SVG namespace.
+        return Boolean(ALL_SVG_TAGS[tagName]);
+      }
+
+      if (element.namespaceURI === MATHML_NAMESPACE) {
+        // The only way to switch from HTML namespace to MathML
+        // is via <math>. If it happens via any other tag, then
+        // it should be killed.
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === 'math';
+        }
+
+        // The only way to switch from SVG to MathML is via
+        // <math> and HTML integration points
+        if (parent.namespaceURI === SVG_NAMESPACE) {
+          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+        }
+
+        // We only allow elements that are defined in MathML
+        // spec. All others are disallowed in MathML namespace.
+        return Boolean(ALL_MATHML_TAGS[tagName]);
+      }
+
+      if (element.namespaceURI === HTML_NAMESPACE) {
+        // The only way to switch from SVG to HTML is via
+        // HTML integration points, and from MathML to HTML
+        // is via MathML text integration points
+        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+
+        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+
+        // Certain elements are allowed in both SVG and HTML
+        // namespace. We need to specify them explicitly
+        // so that they don't get erronously deleted from
+        // HTML namespace.
+        var commonSvgAndHTMLElements = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
+
+        // We disallow tags that are specific for MathML
+        // or SVG and should never appear in HTML namespace
+        return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);
+      }
+
+      // The code should never reach this place (this means
+      // that the element somehow got namespace that is not
+      // HTML, SVG or MathML). Return false just in case.
+      return false;
+    };
+
+    /**
+     * _forceRemove
+     *
+     * @param  {Node} node a DOM node
+     */
+    var _forceRemove = function _forceRemove(node) {
+      arrayPush(DOMPurify.removed, { element: node });
+      try {
+        node.parentNode.removeChild(node);
+      } catch (_) {
+        try {
+          node.outerHTML = emptyHTML;
+        } catch (_) {
+          node.remove();
+        }
+      }
+    };
+
+    /**
+     * _removeAttribute
+     *
+     * @param  {String} name an Attribute name
+     * @param  {Node} node a DOM node
+     */
+    var _removeAttribute = function _removeAttribute(name, node) {
+      try {
+        arrayPush(DOMPurify.removed, {
+          attribute: node.getAttributeNode(name),
+          from: node
+        });
+      } catch (_) {
+        arrayPush(DOMPurify.removed, {
+          attribute: null,
+          from: node
+        });
+      }
+
+      node.removeAttribute(name);
+
+      // We void attribute values for unremovable "is"" attributes
+      if (name === 'is' && !ALLOWED_ATTR[name]) {
+        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+          try {
+            _forceRemove(node);
+          } catch (_) {}
+        } else {
+          try {
+            node.setAttribute(name, '');
+          } catch (_) {}
+        }
+      }
+    };
+
+    /**
+     * _initDocument
+     *
+     * @param  {String} dirty a string of dirty markup
+     * @return {Document} a DOM, filled with the dirty markup
+     */
+    var _initDocument = function _initDocument(dirty) {
+      /* Create a HTML document */
+      var doc = void 0;
+      var leadingWhitespace = void 0;
+
+      if (FORCE_BODY) {
+        dirty = '<remove></remove>' + dirty;
+      } else {
+        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+        var matches = stringMatch(dirty, /^[\r\n\t ]+/);
+        leadingWhitespace = matches && matches[0];
+      }
+
+      var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      /* Use the DOMParser API by default, fallback later if needs be */
+      try {
+        doc = new DOMParser().parseFromString(dirtyPayload, 'text/html');
+      } catch (_) {}
+
+      /* Use createHTMLDocument in case DOMParser is not available */
+      if (!doc || !doc.documentElement) {
+        doc = implementation.createHTMLDocument('');
+        var _doc = doc,
+            body = _doc.body;
+
+        body.parentNode.removeChild(body.parentNode.firstElementChild);
+        body.outerHTML = dirtyPayload;
+      }
+
+      if (dirty && leadingWhitespace) {
+        doc.body.insertBefore(document.createTextNode(leadingWhitespace), doc.body.childNodes[0] || null);
+      }
+
+      /* Work on whole document or just its body */
+      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+    };
+
+    /**
+     * _createIterator
+     *
+     * @param  {Document} root document/fragment to create iterator for
+     * @return {Iterator} iterator instance
+     */
+    var _createIterator = function _createIterator(root) {
+      return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, function () {
+        return NodeFilter.FILTER_ACCEPT;
+      }, false);
+    };
+
+    /**
+     * _isClobbered
+     *
+     * @param  {Node} elm element to check for clobbering attacks
+     * @return {Boolean} true if clobbered, false if safe
+     */
+    var _isClobbered = function _isClobbered(elm) {
+      if (elm instanceof Text || elm instanceof Comment) {
+        return false;
+      }
+
+      if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') {
+        return true;
+      }
+
+      return false;
+    };
+
+    /**
+     * _isNode
+     *
+     * @param  {Node} obj object to check whether it's a DOM node
+     * @return {Boolean} true is object is a DOM node
+     */
+    var _isNode = function _isNode(object) {
+      return (typeof Node === 'undefined' ? 'undefined' : _typeof(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
+    };
+
+    /**
+     * _executeHook
+     * Execute user configurable hooks
+     *
+     * @param  {String} entryPoint  Name of the hook's entry point
+     * @param  {Node} currentNode node to work on with the hook
+     * @param  {Object} data additional hook parameters
+     */
+    var _executeHook = function _executeHook(entryPoint, currentNode, data) {
+      if (!hooks[entryPoint]) {
+        return;
+      }
+
+      arrayForEach(hooks[entryPoint], function (hook) {
+        hook.call(DOMPurify, currentNode, data, CONFIG);
+      });
+    };
+
+    /**
+     * _sanitizeElements
+     *
+     * @protect nodeName
+     * @protect textContent
+     * @protect removeChild
+     *
+     * @param   {Node} currentNode to check for permission to exist
+     * @return  {Boolean} true if node was killed, false if left alive
+     */
+    var _sanitizeElements = function _sanitizeElements(currentNode) {
+      var content = void 0;
+
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeElements', currentNode, null);
+
+      /* Check if element is clobbered or can clobber */
+      if (_isClobbered(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Check if tagname contains Unicode */
+      if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Now let's check the element's type and name */
+      var tagName = stringToLowerCase(currentNode.nodeName);
+
+      /* Execute a hook if present */
+      _executeHook('uponSanitizeElement', currentNode, {
+        tagName: tagName,
+        allowedTags: ALLOWED_TAGS
+      });
+
+      /* Detect mXSS attempts abusing namespace confusion */
+      if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Remove element if anything forbids its presence */
+      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+        /* Keep content except for bad-listed elements */
+        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+          var parentNode = getParentNode(currentNode);
+          var childNodes = getChildNodes(currentNode);
+
+          if (childNodes && parentNode) {
+            var childCount = childNodes.length;
+
+            for (var i = childCount - 1; i >= 0; --i) {
+              parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
+            }
+          }
+        }
+
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Check whether element has a valid namespace */
+      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Sanitize element content to be template-safe */
+      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
+        /* Get the element's text content */
+        content = currentNode.textContent;
+        content = stringReplace(content, MUSTACHE_EXPR$$1, ' ');
+        content = stringReplace(content, ERB_EXPR$$1, ' ');
+        if (currentNode.textContent !== content) {
+          arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+          currentNode.textContent = content;
+        }
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeElements', currentNode, null);
+
+      return false;
+    };
+
+    /**
+     * _isValidAttribute
+     *
+     * @param  {string} lcTag Lowercase tag name of containing element.
+     * @param  {string} lcName Lowercase attribute name.
+     * @param  {string} value Attribute value.
+     * @return {Boolean} Returns true if `value` is valid, otherwise false.
+     */
+    // eslint-disable-next-line complexity
+    var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+      /* Make sure attribute cannot clobber */
+      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
+        return false;
+      }
+
+      /* Allow valid data-* attributes: At least one character after "-"
+          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
+          We don't need to check the value; it's always URI safe. */
+      if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+        return false;
+
+        /* Check value is safe. First, is attr inert? If so, is safe */
+      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if (!value) ; else {
+        return false;
+      }
+
+      return true;
+    };
+
+    /**
+     * _sanitizeAttributes
+     *
+     * @protect attributes
+     * @protect nodeName
+     * @protect removeAttribute
+     * @protect setAttribute
+     *
+     * @param  {Node} currentNode to sanitize
+     */
+    var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+      var attr = void 0;
+      var value = void 0;
+      var lcName = void 0;
+      var l = void 0;
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeAttributes', currentNode, null);
+
+      var attributes = currentNode.attributes;
+
+      /* Check if we have attributes; if not we might have a text node */
+
+      if (!attributes) {
+        return;
+      }
+
+      var hookEvent = {
+        attrName: '',
+        attrValue: '',
+        keepAttr: true,
+        allowedAttributes: ALLOWED_ATTR
+      };
+      l = attributes.length;
+
+      /* Go backwards over all attributes; safely remove bad ones */
+      while (l--) {
+        attr = attributes[l];
+        var _attr = attr,
+            name = _attr.name,
+            namespaceURI = _attr.namespaceURI;
+
+        value = stringTrim(attr.value);
+        lcName = stringToLowerCase(name);
+
+        /* Execute a hook if present */
+        hookEvent.attrName = lcName;
+        hookEvent.attrValue = value;
+        hookEvent.keepAttr = true;
+        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
+        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
+        value = hookEvent.attrValue;
+        /* Did the hooks approve of the attribute? */
+        if (hookEvent.forceKeepAttr) {
+          continue;
+        }
+
+        /* Remove attribute */
+        _removeAttribute(name, currentNode);
+
+        /* Did the hooks approve of the attribute? */
+        if (!hookEvent.keepAttr) {
+          continue;
+        }
+
+        /* Work around a security issue in jQuery 3.0 */
+        if (regExpTest(/\/>/i, value)) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+
+        /* Sanitize attribute content to be template-safe */
+        if (SAFE_FOR_TEMPLATES) {
+          value = stringReplace(value, MUSTACHE_EXPR$$1, ' ');
+          value = stringReplace(value, ERB_EXPR$$1, ' ');
+        }
+
+        /* Is `value` valid for this attribute? */
+        var lcTag = currentNode.nodeName.toLowerCase();
+        if (!_isValidAttribute(lcTag, lcName, value)) {
+          continue;
+        }
+
+        /* Handle invalid data-* attribute set by try-catching it */
+        try {
+          if (namespaceURI) {
+            currentNode.setAttributeNS(namespaceURI, name, value);
+          } else {
+            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+            currentNode.setAttribute(name, value);
+          }
+
+          arrayPop(DOMPurify.removed);
+        } catch (_) {}
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeAttributes', currentNode, null);
+    };
+
+    /**
+     * _sanitizeShadowDOM
+     *
+     * @param  {DocumentFragment} fragment to iterate over recursively
+     */
+    var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+      var shadowNode = void 0;
+      var shadowIterator = _createIterator(fragment);
+
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeShadowDOM', fragment, null);
+
+      while (shadowNode = shadowIterator.nextNode()) {
+        /* Execute a hook if present */
+        _executeHook('uponSanitizeShadowNode', shadowNode, null);
+
+        /* Sanitize tags and elements */
+        if (_sanitizeElements(shadowNode)) {
+          continue;
+        }
+
+        /* Deep shadow DOM detected */
+        if (shadowNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM(shadowNode.content);
+        }
+
+        /* Check attributes, sanitize if necessary */
+        _sanitizeAttributes(shadowNode);
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeShadowDOM', fragment, null);
+    };
+
+    /**
+     * Sanitize
+     * Public method providing core sanitation functionality
+     *
+     * @param {String|Node} dirty string or DOM node
+     * @param {Object} configuration object
+     */
+    // eslint-disable-next-line complexity
+    DOMPurify.sanitize = function (dirty, cfg) {
+      var body = void 0;
+      var importedNode = void 0;
+      var currentNode = void 0;
+      var oldNode = void 0;
+      var returnNode = void 0;
+      /* Make sure we have a string to sanitize.
+        DO NOT return early, as this will return the wrong type if
+        the user has requested a DOM object rather than a string */
+      if (!dirty) {
+        dirty = '<!-->';
+      }
+
+      /* Stringify, in case dirty is an object */
+      if (typeof dirty !== 'string' && !_isNode(dirty)) {
+        // eslint-disable-next-line no-negated-condition
+        if (typeof dirty.toString !== 'function') {
+          throw typeErrorCreate('toString is not a function');
+        } else {
+          dirty = dirty.toString();
+          if (typeof dirty !== 'string') {
+            throw typeErrorCreate('dirty is not a string, aborting');
+          }
+        }
+      }
+
+      /* Check we can run. Otherwise fall back or ignore */
+      if (!DOMPurify.isSupported) {
+        if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {
+          if (typeof dirty === 'string') {
+            return window.toStaticHTML(dirty);
+          }
+
+          if (_isNode(dirty)) {
+            return window.toStaticHTML(dirty.outerHTML);
+          }
+        }
+
+        return dirty;
+      }
+
+      /* Assign config vars */
+      if (!SET_CONFIG) {
+        _parseConfig(cfg);
+      }
+
+      /* Clean up removed elements */
+      DOMPurify.removed = [];
+
+      /* Check if dirty is correctly typed for IN_PLACE */
+      if (typeof dirty === 'string') {
+        IN_PLACE = false;
+      }
+
+      if (IN_PLACE) ; else if (dirty instanceof Node) {
+        /* If dirty is a DOM element, append to an empty document to avoid
+           elements being stripped by the parser */
+        body = _initDocument('<!---->');
+        importedNode = body.ownerDocument.importNode(dirty, true);
+        if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {
+          /* Node is already a body, use as is */
+          body = importedNode;
+        } else if (importedNode.nodeName === 'HTML') {
+          body = importedNode;
+        } else {
+          // eslint-disable-next-line unicorn/prefer-node-append
+          body.appendChild(importedNode);
+        }
+      } else {
+        /* Exit directly if we have nothing to do */
+        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
+        // eslint-disable-next-line unicorn/prefer-includes
+        dirty.indexOf('<') === -1) {
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+        }
+
+        /* Initialize the document to work on */
+        body = _initDocument(dirty);
+
+        /* Check we have a DOM node from the data */
+        if (!body) {
+          return RETURN_DOM ? null : emptyHTML;
+        }
+      }
+
+      /* Remove first element node (ours) if FORCE_BODY is set */
+      if (body && FORCE_BODY) {
+        _forceRemove(body.firstChild);
+      }
+
+      /* Get node iterator */
+      var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+
+      /* Now start iterating over the created document */
+      while (currentNode = nodeIterator.nextNode()) {
+        /* Fix IE's strange behavior with manipulated textNodes #89 */
+        if (currentNode.nodeType === 3 && currentNode === oldNode) {
+          continue;
+        }
+
+        /* Sanitize tags and elements */
+        if (_sanitizeElements(currentNode)) {
+          continue;
+        }
+
+        /* Shadow DOM detected, sanitize it */
+        if (currentNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM(currentNode.content);
+        }
+
+        /* Check attributes, sanitize if necessary */
+        _sanitizeAttributes(currentNode);
+
+        oldNode = currentNode;
+      }
+
+      oldNode = null;
+
+      /* If we sanitized `dirty` in-place, return it. */
+      if (IN_PLACE) {
+        return dirty;
+      }
+
+      /* Return sanitized string or DOM */
+      if (RETURN_DOM) {
+        if (RETURN_DOM_FRAGMENT) {
+          returnNode = createDocumentFragment.call(body.ownerDocument);
+
+          while (body.firstChild) {
+            // eslint-disable-next-line unicorn/prefer-node-append
+            returnNode.appendChild(body.firstChild);
+          }
+        } else {
+          returnNode = body;
+        }
+
+        if (RETURN_DOM_IMPORT) {
+          /*
+            AdoptNode() is not used because internal state is not reset
+            (e.g. the past names map of a HTMLFormElement), this is safe
+            in theory but we would rather not risk another attack vector.
+            The state that is cloned by importNode() is explicitly defined
+            by the specs.
+          */
+          returnNode = importNode.call(originalDocument, returnNode, true);
+        }
+
+        return returnNode;
+      }
+
+      var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+
+      /* Sanitize final string template-safe */
+      if (SAFE_FOR_TEMPLATES) {
+        serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' ');
+        serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' ');
+      }
+
+      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+    };
+
+    /**
+     * Public method to set the configuration once
+     * setConfig
+     *
+     * @param {Object} cfg configuration object
+     */
+    DOMPurify.setConfig = function (cfg) {
+      _parseConfig(cfg);
+      SET_CONFIG = true;
+    };
+
+    /**
+     * Public method to remove the configuration
+     * clearConfig
+     *
+     */
+    DOMPurify.clearConfig = function () {
+      CONFIG = null;
+      SET_CONFIG = false;
+    };
+
+    /**
+     * Public method to check if an attribute value is valid.
+     * Uses last set config, if any. Otherwise, uses config defaults.
+     * isValidAttribute
+     *
+     * @param  {string} tag Tag name of containing element.
+     * @param  {string} attr Attribute name.
+     * @param  {string} value Attribute value.
+     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.
+     */
+    DOMPurify.isValidAttribute = function (tag, attr, value) {
+      /* Initialize shared config vars if necessary. */
+      if (!CONFIG) {
+        _parseConfig({});
+      }
+
+      var lcTag = stringToLowerCase(tag);
+      var lcName = stringToLowerCase(attr);
+      return _isValidAttribute(lcTag, lcName, value);
+    };
+
+    /**
+     * AddHook
+     * Public method to add DOMPurify hooks
+     *
+     * @param {String} entryPoint entry point for the hook to add
+     * @param {Function} hookFunction function to execute
+     */
+    DOMPurify.addHook = function (entryPoint, hookFunction) {
+      if (typeof hookFunction !== 'function') {
+        return;
+      }
+
+      hooks[entryPoint] = hooks[entryPoint] || [];
+      arrayPush(hooks[entryPoint], hookFunction);
+    };
+
+    /**
+     * RemoveHook
+     * Public method to remove a DOMPurify hook at a given entryPoint
+     * (pops it from the stack of hooks if more are present)
+     *
+     * @param {String} entryPoint entry point for the hook to remove
+     */
+    DOMPurify.removeHook = function (entryPoint) {
+      if (hooks[entryPoint]) {
+        arrayPop(hooks[entryPoint]);
+      }
+    };
+
+    /**
+     * RemoveHooks
+     * Public method to remove all DOMPurify hooks at a given entryPoint
+     *
+     * @param  {String} entryPoint entry point for the hooks to remove
+     */
+    DOMPurify.removeHooks = function (entryPoint) {
+      if (hooks[entryPoint]) {
+        hooks[entryPoint] = [];
+      }
+    };
+
+    /**
+     * RemoveAllHooks
+     * Public method to remove all DOMPurify hooks
+     *
+     */
+    DOMPurify.removeAllHooks = function () {
+      hooks = {};
+    };
+
+    return DOMPurify;
+  }
+
+  var purify = createDOMPurify();
+
+  return purify;
+
+}));
+//# sourceMappingURL=purify.js.map
+
+
+/***/ }),
+
+/***/ "./node_modules/dot-case/dist.es2015/index.js":
+/*!****************************************************!*\
+  !*** ./node_modules/dot-case/dist.es2015/index.js ***!
+  \****************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "dotCase": () => (/* binding */ dotCase)
+/* harmony export */ });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
+/* harmony import */ var no_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! no-case */ "./node_modules/no-case/dist.es2015/index.js");
+
+
+function dotCase(input, options) {
+    if (options === void 0) { options = {}; }
+    return (0,no_case__WEBPACK_IMPORTED_MODULE_0__.noCase)(input, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__assign)({ delimiter: "." }, options));
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/eventemitter3/index.js":
+/*!*********************************************!*\
+  !*** ./node_modules/eventemitter3/index.js ***!
+  \*********************************************/
+/***/ ((module) => {
+
+"use strict";
+
+
+var has = Object.prototype.hasOwnProperty
+  , prefix = '~';
+
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+function Events() {}
+
+//
+// We try to not inherit from `Object.prototype`. In some engines creating an
+// instance in this way is faster than calling `Object.create(null)` directly.
+// If `Object.create(null)` is not supported we prefix the event names with a
+// character to make sure that the built-in object properties are not
+// overridden or used as an attack vector.
+//
+if (Object.create) {
+  Events.prototype = Object.create(null);
+
+  //
+  // This hack is needed because the `__proto__` property is still inherited in
+  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+  //
+  if (!new Events().__proto__) prefix = false;
+}
+
+/**
+ * Representation of a single event listener.
+ *
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+ * @constructor
+ * @private
+ */
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} once Specify if the listener is a one-time listener.
+ * @returns {EventEmitter}
+ * @private
+ */
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The listener must be a function');
+  }
+
+  var listener = new EE(fn, context || emitter, once)
+    , evt = prefix ? prefix + event : event;
+
+  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+  else emitter._events[evt] = [emitter._events[evt], listener];
+
+  return emitter;
+}
+
+/**
+ * Clear event by name.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} evt The Event name.
+ * @private
+ */
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();
+  else delete emitter._events[evt];
+}
+
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+
+/**
+ * Return an array listing the events for which the emitter has registered
+ * listeners.
+ *
+ * @returns {Array}
+ * @public
+ */
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = []
+    , events
+    , name;
+
+  if (this._eventsCount === 0) return names;
+
+  for (name in (events = this._events)) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+
+  return names;
+};
+
+/**
+ * Return the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Array} The registered listeners.
+ * @public
+ */
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event
+    , handlers = this._events[evt];
+
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+
+  return ee;
+};
+
+/**
+ * Return the number of listeners listening to a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Number} The number of listeners.
+ * @public
+ */
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event
+    , listeners = this._events[evt];
+
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+
+/**
+ * Calls each of the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
+ * @public
+ */
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return false;
+
+  var listeners = this._events[evt]
+    , len = arguments.length
+    , args
+    , i;
+
+  if (listeners.fn) {
+    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+    switch (len) {
+      case 1: return listeners.fn.call(listeners.context), true;
+      case 2: return listeners.fn.call(listeners.context, a1), true;
+      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+    }
+
+    for (i = 1, args = new Array(len -1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length
+      , j;
+
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+      switch (len) {
+        case 1: listeners[i].fn.call(listeners[i].context); break;
+        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+        default:
+          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+            args[j - 1] = arguments[j];
+          }
+
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+
+/**
+ * Add a one-time listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+
+/**
+ * Remove the listeners of a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn Only remove the listeners that match this function.
+ * @param {*} context Only remove the listeners that have this context.
+ * @param {Boolean} once Only remove one-time listeners.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return this;
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+
+  var listeners = this._events[evt];
+
+  if (listeners.fn) {
+    if (
+      listeners.fn === fn &&
+      (!once || listeners.once) &&
+      (!context || listeners.context === context)
+    ) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (
+        listeners[i].fn !== fn ||
+        (once && !listeners[i].once) ||
+        (context && listeners[i].context !== context)
+      ) {
+        events.push(listeners[i]);
+      }
+    }
+
+    //
+    // Reset the array, or remove it completely if we have no more listeners.
+    //
+    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+    else clearEvent(this, evt);
+  }
+
+  return this;
+};
+
+/**
+ * Remove all listeners, or those of the specified event.
+ *
+ * @param {(String|Symbol)} [event] The event name.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  return this;
+};
+
+//
+// Alias methods names because people roll like that.
+//
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+//
+// Expose the prefix.
+//
+EventEmitter.prefixed = prefix;
+
+//
+// Allow `EventEmitter` to be imported as module namespace.
+//
+EventEmitter.EventEmitter = EventEmitter;
+
+//
+// Expose the module.
+//
+if (true) {
+  module.exports = EventEmitter;
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/inherits/inherits_browser.js":
+/*!***************************************************!*\
+  !*** ./node_modules/inherits/inherits_browser.js ***!
+  \***************************************************/
+/***/ ((module) => {
+
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/lower-case/dist.es2015/index.js":
+/*!******************************************************!*\
+  !*** ./node_modules/lower-case/dist.es2015/index.js ***!
+  \******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "localeLowerCase": () => (/* binding */ localeLowerCase),
+/* harmony export */   "lowerCase": () => (/* binding */ lowerCase)
+/* harmony export */ });
+/**
+ * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
+ */
+var SUPPORTED_LOCALE = {
+    tr: {
+        regexp: /\u0130|\u0049|\u0049\u0307/g,
+        map: {
+            İ: "\u0069",
+            I: "\u0131",
+            İ: "\u0069",
+        },
+    },
+    az: {
+        regexp: /\u0130/g,
+        map: {
+            İ: "\u0069",
+            I: "\u0131",
+            İ: "\u0069",
+        },
+    },
+    lt: {
+        regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
+        map: {
+            I: "\u0069\u0307",
+            J: "\u006A\u0307",
+            Į: "\u012F\u0307",
+            Ì: "\u0069\u0307\u0300",
+            Í: "\u0069\u0307\u0301",
+            Ĩ: "\u0069\u0307\u0303",
+        },
+    },
+};
+/**
+ * Localized lower case.
+ */
+function localeLowerCase(str, locale) {
+    var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
+    if (lang)
+        return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
+    return lowerCase(str);
+}
+/**
+ * Lower case as a function.
+ */
+function lowerCase(str) {
+    return str.toLowerCase();
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/ms/index.js":
+/*!**********************************!*\
+  !*** ./node_modules/ms/index.js ***!
+  \**********************************/
+/***/ ((module) => {
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/no-case/dist.es2015/index.js":
+/*!***************************************************!*\
+  !*** ./node_modules/no-case/dist.es2015/index.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "noCase": () => (/* binding */ noCase)
+/* harmony export */ });
+/* harmony import */ var lower_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lower-case */ "./node_modules/lower-case/dist.es2015/index.js");
+
+// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
+var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+// Remove all non-word characters.
+var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+/**
+ * Normalize the string into something other libraries can manipulate easier.
+ */
+function noCase(input, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lower_case__WEBPACK_IMPORTED_MODULE_0__.lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
+    var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+    var start = 0;
+    var end = result.length;
+    // Trim the delimiter from around the output string.
+    while (result.charAt(start) === "\0")
+        start++;
+    while (result.charAt(end - 1) === "\0")
+        end--;
+    // Transform each token independently.
+    return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+/**
+ * Replace `re` in the input string with the replacement value.
+ */
+function replace(input, re, value) {
+    if (re instanceof RegExp)
+        return input.replace(re, value);
+    return re.reduce(function (input, re) { return input.replace(re, value); }, input);
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/path/path.js":
+/*!***********************************!*\
+  !*** ./node_modules/path/path.js ***!
+  \***********************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+var isWindows = process.platform === 'win32';
+var util = __webpack_require__(/*! util */ "./node_modules/util/util.js");
+
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+  var res = [];
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i];
+
+    // ignore empty parts
+    if (!p || p === '.')
+      continue;
+
+    if (p === '..') {
+      if (res.length && res[res.length - 1] !== '..') {
+        res.pop();
+      } else if (allowAboveRoot) {
+        res.push('..');
+      }
+    } else {
+      res.push(p);
+    }
+  }
+
+  return res;
+}
+
+// returns an array with empty elements removed from either end of the input
+// array or the original array if no elements need to be removed
+function trimArray(arr) {
+  var lastIndex = arr.length - 1;
+  var start = 0;
+  for (; start <= lastIndex; start++) {
+    if (arr[start])
+      break;
+  }
+
+  var end = lastIndex;
+  for (; end >= 0; end--) {
+    if (arr[end])
+      break;
+  }
+
+  if (start === 0 && end === lastIndex)
+    return arr;
+  if (start > end)
+    return [];
+  return arr.slice(start, end + 1);
+}
+
+// Regex to split a windows path into three parts: [*, device, slash,
+// tail] windows-only
+var splitDeviceRe =
+    /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+// Regex to split the tail part of the above into [*, dir, basename, ext]
+var splitTailRe =
+    /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+var win32 = {};
+
+// Function to split a filename into [root, dir, basename, ext]
+function win32SplitPath(filename) {
+  // Separate device+slash from tail
+  var result = splitDeviceRe.exec(filename),
+      device = (result[1] || '') + (result[2] || ''),
+      tail = result[3] || '';
+  // Split the tail into dir, basename and extension
+  var result2 = splitTailRe.exec(tail),
+      dir = result2[1],
+      basename = result2[2],
+      ext = result2[3];
+  return [device, dir, basename, ext];
+}
+
+function win32StatPath(path) {
+  var result = splitDeviceRe.exec(path),
+      device = result[1] || '',
+      isUnc = !!device && device[1] !== ':';
+  return {
+    device: device,
+    isUnc: isUnc,
+    isAbsolute: isUnc || !!result[2], // UNC paths are always absolute
+    tail: result[3]
+  };
+}
+
+function normalizeUNCRoot(device) {
+  return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
+}
+
+// path.resolve([from ...], to)
+win32.resolve = function() {
+  var resolvedDevice = '',
+      resolvedTail = '',
+      resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1; i--) {
+    var path;
+    if (i >= 0) {
+      path = arguments[i];
+    } else if (!resolvedDevice) {
+      path = process.cwd();
+    } else {
+      // Windows has the concept of drive-specific current working
+      // directories. If we've resolved a drive letter but not yet an
+      // absolute path, get cwd for that drive. We're sure the device is not
+      // an unc path at this points, because unc paths are always absolute.
+      path = process.env['=' + resolvedDevice];
+      // Verify that a drive-local cwd was found and that it actually points
+      // to our drive. If not, default to the drive's root.
+      if (!path || path.substr(0, 3).toLowerCase() !==
+          resolvedDevice.toLowerCase() + '\\') {
+        path = resolvedDevice + '\\';
+      }
+    }
+
+    // Skip empty and invalid entries
+    if (!util.isString(path)) {
+      throw new TypeError('Arguments to path.resolve must be strings');
+    } else if (!path) {
+      continue;
+    }
+
+    var result = win32StatPath(path),
+        device = result.device,
+        isUnc = result.isUnc,
+        isAbsolute = result.isAbsolute,
+        tail = result.tail;
+
+    if (device &&
+        resolvedDevice &&
+        device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+      // This path points to another device so it is not applicable
+      continue;
+    }
+
+    if (!resolvedDevice) {
+      resolvedDevice = device;
+    }
+    if (!resolvedAbsolute) {
+      resolvedTail = tail + '\\' + resolvedTail;
+      resolvedAbsolute = isAbsolute;
+    }
+
+    if (resolvedDevice && resolvedAbsolute) {
+      break;
+    }
+  }
+
+  // Convert slashes to backslashes when `resolvedDevice` points to an UNC
+  // root. Also squash multiple slashes into a single one where appropriate.
+  if (isUnc) {
+    resolvedDevice = normalizeUNCRoot(resolvedDevice);
+  }
+
+  // At this point the path should be resolved to a full absolute path,
+  // but handle relative paths to be safe (might happen when process.cwd()
+  // fails)
+
+  // Normalize the tail path
+  resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/),
+                                !resolvedAbsolute).join('\\');
+
+  return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
+         '.';
+};
+
+
+win32.normalize = function(path) {
+  var result = win32StatPath(path),
+      device = result.device,
+      isUnc = result.isUnc,
+      isAbsolute = result.isAbsolute,
+      tail = result.tail,
+      trailingSlash = /[\\\/]$/.test(tail);
+
+  // Normalize the tail path
+  tail = normalizeArray(tail.split(/[\\\/]+/), !isAbsolute).join('\\');
+
+  if (!tail && !isAbsolute) {
+    tail = '.';
+  }
+  if (tail && trailingSlash) {
+    tail += '\\';
+  }
+
+  // Convert slashes to backslashes when `device` points to an UNC root.
+  // Also squash multiple slashes into a single one where appropriate.
+  if (isUnc) {
+    device = normalizeUNCRoot(device);
+  }
+
+  return device + (isAbsolute ? '\\' : '') + tail;
+};
+
+
+win32.isAbsolute = function(path) {
+  return win32StatPath(path).isAbsolute;
+};
+
+win32.join = function() {
+  var paths = [];
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    if (!util.isString(arg)) {
+      throw new TypeError('Arguments to path.join must be strings');
+    }
+    if (arg) {
+      paths.push(arg);
+    }
+  }
+
+  var joined = paths.join('\\');
+
+  // Make sure that the joined path doesn't start with two slashes, because
+  // normalize() will mistake it for an UNC path then.
+  //
+  // This step is skipped when it is very clear that the user actually
+  // intended to point at an UNC path. This is assumed when the first
+  // non-empty string arguments starts with exactly two slashes followed by
+  // at least one more non-slash character.
+  //
+  // Note that for normalize() to treat a path as an UNC path it needs to
+  // have at least 2 components, so we don't filter for that here.
+  // This means that the user can use join to construct UNC paths from
+  // a server name and a share name; for example:
+  //   path.join('//server', 'share') -> '\\\\server\\share\')
+  if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+    joined = joined.replace(/^[\\\/]{2,}/, '\\');
+  }
+
+  return win32.normalize(joined);
+};
+
+
+// path.relative(from, to)
+// it will solve the relative path from 'from' to 'to', for instance:
+// from = 'C:\\orandea\\test\\aaa'
+// to = 'C:\\orandea\\impl\\bbb'
+// The output of the function should be: '..\\..\\impl\\bbb'
+win32.relative = function(from, to) {
+  from = win32.resolve(from);
+  to = win32.resolve(to);
+
+  // windows is not case sensitive
+  var lowerFrom = from.toLowerCase();
+  var lowerTo = to.toLowerCase();
+
+  var toParts = trimArray(to.split('\\'));
+
+  var lowerFromParts = trimArray(lowerFrom.split('\\'));
+  var lowerToParts = trimArray(lowerTo.split('\\'));
+
+  var length = Math.min(lowerFromParts.length, lowerToParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (lowerFromParts[i] !== lowerToParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  if (samePartsLength == 0) {
+    return to;
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('\\');
+};
+
+
+win32._makeLong = function(path) {
+  // Note: this will *probably* throw somewhere.
+  if (!util.isString(path))
+    return path;
+
+  if (!path) {
+    return '';
+  }
+
+  var resolvedPath = win32.resolve(path);
+
+  if (/^[a-zA-Z]\:\\/.test(resolvedPath)) {
+    // path is local filesystem path, which needs to be converted
+    // to long UNC path.
+    return '\\\\?\\' + resolvedPath;
+  } else if (/^\\\\[^?.]/.test(resolvedPath)) {
+    // path is network UNC path, which needs to be converted
+    // to long UNC path.
+    return '\\\\?\\UNC\\' + resolvedPath.substring(2);
+  }
+
+  return path;
+};
+
+
+win32.dirname = function(path) {
+  var result = win32SplitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+};
+
+
+win32.basename = function(path, ext) {
+  var f = win32SplitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+win32.extname = function(path) {
+  return win32SplitPath(path)[3];
+};
+
+
+win32.format = function(pathObject) {
+  if (!util.isObject(pathObject)) {
+    throw new TypeError(
+        "Parameter 'pathObject' must be an object, not " + typeof pathObject
+    );
+  }
+
+  var root = pathObject.root || '';
+
+  if (!util.isString(root)) {
+    throw new TypeError(
+        "'pathObject.root' must be a string or undefined, not " +
+        typeof pathObject.root
+    );
+  }
+
+  var dir = pathObject.dir;
+  var base = pathObject.base || '';
+  if (!dir) {
+    return base;
+  }
+  if (dir[dir.length - 1] === win32.sep) {
+    return dir + base;
+  }
+  return dir + win32.sep + base;
+};
+
+
+win32.parse = function(pathString) {
+  if (!util.isString(pathString)) {
+    throw new TypeError(
+        "Parameter 'pathString' must be a string, not " + typeof pathString
+    );
+  }
+  var allParts = win32SplitPath(pathString);
+  if (!allParts || allParts.length !== 4) {
+    throw new TypeError("Invalid path '" + pathString + "'");
+  }
+  return {
+    root: allParts[0],
+    dir: allParts[0] + allParts[1].slice(0, -1),
+    base: allParts[2],
+    ext: allParts[3],
+    name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+  };
+};
+
+
+win32.sep = '\\';
+win32.delimiter = ';';
+
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var posix = {};
+
+
+function posixSplitPath(filename) {
+  return splitPathRe.exec(filename).slice(1);
+}
+
+
+// path.resolve([from ...], to)
+// posix version
+posix.resolve = function() {
+  var resolvedPath = '',
+      resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    var path = (i >= 0) ? arguments[i] : process.cwd();
+
+    // Skip empty and invalid entries
+    if (!util.isString(path)) {
+      throw new TypeError('Arguments to path.resolve must be strings');
+    } else if (!path) {
+      continue;
+    }
+
+    resolvedPath = path + '/' + resolvedPath;
+    resolvedAbsolute = path[0] === '/';
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeArray(resolvedPath.split('/'),
+                                !resolvedAbsolute).join('/');
+
+  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+};
+
+// path.normalize(path)
+// posix version
+posix.normalize = function(path) {
+  var isAbsolute = posix.isAbsolute(path),
+      trailingSlash = path && path[path.length - 1] === '/';
+
+  // Normalize the path
+  path = normalizeArray(path.split('/'), !isAbsolute).join('/');
+
+  if (!path && !isAbsolute) {
+    path = '.';
+  }
+  if (path && trailingSlash) {
+    path += '/';
+  }
+
+  return (isAbsolute ? '/' : '') + path;
+};
+
+// posix version
+posix.isAbsolute = function(path) {
+  return path.charAt(0) === '/';
+};
+
+// posix version
+posix.join = function() {
+  var path = '';
+  for (var i = 0; i < arguments.length; i++) {
+    var segment = arguments[i];
+    if (!util.isString(segment)) {
+      throw new TypeError('Arguments to path.join must be strings');
+    }
+    if (segment) {
+      if (!path) {
+        path += segment;
+      } else {
+        path += '/' + segment;
+      }
+    }
+  }
+  return posix.normalize(path);
+};
+
+
+// path.relative(from, to)
+// posix version
+posix.relative = function(from, to) {
+  from = posix.resolve(from).substr(1);
+  to = posix.resolve(to).substr(1);
+
+  var fromParts = trimArray(from.split('/'));
+  var toParts = trimArray(to.split('/'));
+
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('/');
+};
+
+
+posix._makeLong = function(path) {
+  return path;
+};
+
+
+posix.dirname = function(path) {
+  var result = posixSplitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+};
+
+
+posix.basename = function(path, ext) {
+  var f = posixSplitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+posix.extname = function(path) {
+  return posixSplitPath(path)[3];
+};
+
+
+posix.format = function(pathObject) {
+  if (!util.isObject(pathObject)) {
+    throw new TypeError(
+        "Parameter 'pathObject' must be an object, not " + typeof pathObject
+    );
+  }
+
+  var root = pathObject.root || '';
+
+  if (!util.isString(root)) {
+    throw new TypeError(
+        "'pathObject.root' must be a string or undefined, not " +
+        typeof pathObject.root
+    );
+  }
+
+  var dir = pathObject.dir ? pathObject.dir + posix.sep : '';
+  var base = pathObject.base || '';
+  return dir + base;
+};
+
+
+posix.parse = function(pathString) {
+  if (!util.isString(pathString)) {
+    throw new TypeError(
+        "Parameter 'pathString' must be a string, not " + typeof pathString
+    );
+  }
+  var allParts = posixSplitPath(pathString);
+  if (!allParts || allParts.length !== 4) {
+    throw new TypeError("Invalid path '" + pathString + "'");
+  }
+  allParts[1] = allParts[1] || '';
+  allParts[2] = allParts[2] || '';
+  allParts[3] = allParts[3] || '';
+
+  return {
+    root: allParts[0],
+    dir: allParts[0] + allParts[1].slice(0, -1),
+    base: allParts[2],
+    ext: allParts[3],
+    name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+  };
+};
+
+
+posix.sep = '/';
+posix.delimiter = ':';
+
+
+if (isWindows)
+  module.exports = win32;
+else /* posix */
+  module.exports = posix;
+
+module.exports.posix = posix;
+module.exports.win32 = win32;
+
+
+/***/ }),
+
+/***/ "./node_modules/postmate/build/postmate.es.js":
+/*!****************************************************!*\
+  !*** ./node_modules/postmate/build/postmate.es.js ***!
+  \****************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+  postmate - A powerful, simple, promise-based postMessage library
+  @version v1.5.2
+  @link https://github.com/dollarshaveclub/postmate
+  @author Jacob Kelley <jakie8@gmail.com>
+  @license MIT
+**/
+/**
+ * The type of messages our frames our sending
+ * @type {String}
+ */
+var messageType = 'application/x-postmate-v1+json';
+/**
+ * The maximum number of attempts to send a handshake request to the parent
+ * @type {Number}
+ */
+
+var maxHandshakeRequests = 5;
+/**
+ * A unique message ID that is used to ensure responses are sent to the correct requests
+ * @type {Number}
+ */
+
+var _messageId = 0;
+/**
+ * Increments and returns a message ID
+ * @return {Number} A unique ID for a message
+ */
+
+var generateNewMessageId = function generateNewMessageId() {
+  return ++_messageId;
+};
+/**
+ * Postmate logging function that enables/disables via config
+ * @param  {Object} ...args Rest Arguments
+ */
+
+var log = function log() {
+  var _console;
+
+  return Postmate.debug ? (_console = console).log.apply(_console, arguments) : null;
+}; // eslint-disable-line no-console
+
+/**
+ * Takes a URL and returns the origin
+ * @param  {String} url The full URL being requested
+ * @return {String}     The URLs origin
+ */
+
+var resolveOrigin = function resolveOrigin(url) {
+  var a = document.createElement('a');
+  a.href = url;
+  var protocol = a.protocol.length > 4 ? a.protocol : window.location.protocol;
+  var host = a.host.length ? a.port === '80' || a.port === '443' ? a.hostname : a.host : window.location.host;
+  return a.origin || protocol + "//" + host;
+};
+var messageTypes = {
+  handshake: 1,
+  'handshake-reply': 1,
+  call: 1,
+  emit: 1,
+  reply: 1,
+  request: 1
+  /**
+   * Ensures that a message is safe to interpret
+   * @param  {Object} message The postmate message being sent
+   * @param  {String|Boolean} allowedOrigin The whitelisted origin or false to skip origin check
+   * @return {Boolean}
+   */
+
+};
+var sanitize = function sanitize(message, allowedOrigin) {
+  if (typeof allowedOrigin === 'string' && message.origin !== allowedOrigin) return false;
+  if (!message.data) return false;
+  if (typeof message.data === 'object' && !('postmate' in message.data)) return false;
+  if (message.data.type !== messageType) return false;
+  if (!messageTypes[message.data.postmate]) return false;
+  return true;
+};
+/**
+ * Takes a model, and searches for a value by the property
+ * @param  {Object} model     The dictionary to search against
+ * @param  {String} property  A path within a dictionary (i.e. 'window.location.href')
+ * @param  {Object} data      Additional information from the get request that is
+ *                            passed to functions in the child model
+ * @return {Promise}
+ */
+
+var resolveValue = function resolveValue(model, property) {
+  var unwrappedContext = typeof model[property] === 'function' ? model[property]() : model[property];
+  return Postmate.Promise.resolve(unwrappedContext);
+};
+/**
+ * Composes an API to be used by the parent
+ * @param {Object} info Information on the consumer
+ */
+
+var ParentAPI =
+/*#__PURE__*/
+function () {
+  function ParentAPI(info) {
+    var _this = this;
+
+    this.parent = info.parent;
+    this.frame = info.frame;
+    this.child = info.child;
+    this.childOrigin = info.childOrigin;
+    this.events = {};
+
+    if (true) {
+      log('Parent: Registering API');
+      log('Parent: Awaiting messages...');
+    }
+
+    this.listener = function (e) {
+      if (!sanitize(e, _this.childOrigin)) return false;
+      /**
+       * the assignments below ensures that e, data, and value are all defined
+       */
+
+      var _ref = ((e || {}).data || {}).value || {},
+          data = _ref.data,
+          name = _ref.name;
+
+      if (e.data.postmate === 'emit') {
+        if (true) {
+          log("Parent: Received event emission: " + name);
+        }
+
+        if (name in _this.events) {
+          _this.events[name].call(_this, data);
+        }
+      }
+    };
+
+    this.parent.addEventListener('message', this.listener, false);
+
+    if (true) {
+      log('Parent: Awaiting event emissions from Child');
+    }
+  }
+
+  var _proto = ParentAPI.prototype;
+
+  _proto.get = function get(property) {
+    var _this2 = this;
+
+    return new Postmate.Promise(function (resolve) {
+      // Extract data from response and kill listeners
+      var uid = generateNewMessageId();
+
+      var transact = function transact(e) {
+        if (e.data.uid === uid && e.data.postmate === 'reply') {
+          _this2.parent.removeEventListener('message', transact, false);
+
+          resolve(e.data.value);
+        }
+      }; // Prepare for response from Child...
+
+
+      _this2.parent.addEventListener('message', transact, false); // Then ask child for information
+
+
+      _this2.child.postMessage({
+        postmate: 'request',
+        type: messageType,
+        property: property,
+        uid: uid
+      }, _this2.childOrigin);
+    });
+  };
+
+  _proto.call = function call(property, data) {
+    // Send information to the child
+    this.child.postMessage({
+      postmate: 'call',
+      type: messageType,
+      property: property,
+      data: data
+    }, this.childOrigin);
+  };
+
+  _proto.on = function on(eventName, callback) {
+    this.events[eventName] = callback;
+  };
+
+  _proto.destroy = function destroy() {
+    if (true) {
+      log('Parent: Destroying Postmate instance');
+    }
+
+    window.removeEventListener('message', this.listener, false);
+    this.frame.parentNode.removeChild(this.frame);
+  };
+
+  return ParentAPI;
+}();
+/**
+ * Composes an API to be used by the child
+ * @param {Object} info Information on the consumer
+ */
+
+var ChildAPI =
+/*#__PURE__*/
+function () {
+  function ChildAPI(info) {
+    var _this3 = this;
+
+    this.model = info.model;
+    this.parent = info.parent;
+    this.parentOrigin = info.parentOrigin;
+    this.child = info.child;
+
+    if (true) {
+      log('Child: Registering API');
+      log('Child: Awaiting messages...');
+    }
+
+    this.child.addEventListener('message', function (e) {
+      if (!sanitize(e, _this3.parentOrigin)) return;
+
+      if (true) {
+        log('Child: Received request', e.data);
+      }
+
+      var _e$data = e.data,
+          property = _e$data.property,
+          uid = _e$data.uid,
+          data = _e$data.data;
+
+      if (e.data.postmate === 'call') {
+        if (property in _this3.model && typeof _this3.model[property] === 'function') {
+          _this3.model[property](data);
+        }
+
+        return;
+      } // Reply to Parent
+
+
+      resolveValue(_this3.model, property).then(function (value) {
+        return e.source.postMessage({
+          property: property,
+          postmate: 'reply',
+          type: messageType,
+          uid: uid,
+          value: value
+        }, e.origin);
+      });
+    });
+  }
+
+  var _proto2 = ChildAPI.prototype;
+
+  _proto2.emit = function emit(name, data) {
+    if (true) {
+      log("Child: Emitting Event \"" + name + "\"", data);
+    }
+
+    this.parent.postMessage({
+      postmate: 'emit',
+      type: messageType,
+      value: {
+        name: name,
+        data: data
+      }
+    }, this.parentOrigin);
+  };
+
+  return ChildAPI;
+}();
+/**
+  * The entry point of the Parent.
+ * @type {Class}
+ */
+
+var Postmate =
+/*#__PURE__*/
+function () {
+  // eslint-disable-line no-undef
+  // Internet Explorer craps itself
+
+  /**
+   * Sets options related to the Parent
+   * @param {Object} object The element to inject the frame into, and the url
+   * @return {Promise}
+   */
+  function Postmate(_ref2) {
+    var _ref2$container = _ref2.container,
+        container = _ref2$container === void 0 ? typeof container !== 'undefined' ? container : document.body : _ref2$container,
+        model = _ref2.model,
+        url = _ref2.url,
+        name = _ref2.name,
+        _ref2$classListArray = _ref2.classListArray,
+        classListArray = _ref2$classListArray === void 0 ? [] : _ref2$classListArray;
+    // eslint-disable-line no-undef
+    this.parent = window;
+    this.frame = document.createElement('iframe');
+    this.frame.name = name || '';
+    this.frame.classList.add.apply(this.frame.classList, classListArray);
+    container.appendChild(this.frame);
+    this.child = this.frame.contentWindow || this.frame.contentDocument.parentWindow;
+    this.model = model || {};
+    return this.sendHandshake(url);
+  }
+  /**
+   * Begins the handshake strategy
+   * @param  {String} url The URL to send a handshake request to
+   * @return {Promise}     Promise that resolves when the handshake is complete
+   */
+
+
+  var _proto3 = Postmate.prototype;
+
+  _proto3.sendHandshake = function sendHandshake(url) {
+    var _this4 = this;
+
+    var childOrigin = resolveOrigin(url);
+    var attempt = 0;
+    var responseInterval;
+    return new Postmate.Promise(function (resolve, reject) {
+      var reply = function reply(e) {
+        if (!sanitize(e, childOrigin)) return false;
+
+        if (e.data.postmate === 'handshake-reply') {
+          clearInterval(responseInterval);
+
+          if (true) {
+            log('Parent: Received handshake reply from Child');
+          }
+
+          _this4.parent.removeEventListener('message', reply, false);
+
+          _this4.childOrigin = e.origin;
+
+          if (true) {
+            log('Parent: Saving Child origin', _this4.childOrigin);
+          }
+
+          return resolve(new ParentAPI(_this4));
+        } // Might need to remove since parent might be receiving different messages
+        // from different hosts
+
+
+        if (true) {
+          log('Parent: Invalid handshake reply');
+        }
+
+        return reject('Failed handshake');
+      };
+
+      _this4.parent.addEventListener('message', reply, false);
+
+      var doSend = function doSend() {
+        attempt++;
+
+        if (true) {
+          log("Parent: Sending handshake attempt " + attempt, {
+            childOrigin: childOrigin
+          });
+        }
+
+        _this4.child.postMessage({
+          postmate: 'handshake',
+          type: messageType,
+          model: _this4.model
+        }, childOrigin);
+
+        if (attempt === maxHandshakeRequests) {
+          clearInterval(responseInterval);
+        }
+      };
+
+      var loaded = function loaded() {
+        doSend();
+        responseInterval = setInterval(doSend, 500);
+      };
+
+      if (_this4.frame.attachEvent) {
+        _this4.frame.attachEvent('onload', loaded);
+      } else {
+        _this4.frame.onload = loaded;
+      }
+
+      if (true) {
+        log('Parent: Loading frame', {
+          url: url
+        });
+      }
+
+      _this4.frame.src = url;
+    });
+  };
+
+  return Postmate;
+}();
+/**
+ * The entry point of the Child
+ * @type {Class}
+ */
+
+
+Postmate.debug = false;
+
+Postmate.Promise = function () {
+  try {
+    return window ? window.Promise : Promise;
+  } catch (e) {
+    return null;
+  }
+}();
+
+Postmate.Model =
+/*#__PURE__*/
+function () {
+  /**
+   * Initializes the child, model, parent, and responds to the Parents handshake
+   * @param {Object} model Hash of values, functions, or promises
+   * @return {Promise}       The Promise that resolves when the handshake has been received
+   */
+  function Model(model) {
+    this.child = window;
+    this.model = model;
+    this.parent = this.child.parent;
+    return this.sendHandshakeReply();
+  }
+  /**
+   * Responds to a handshake initiated by the Parent
+   * @return {Promise} Resolves an object that exposes an API for the Child
+   */
+
+
+  var _proto4 = Model.prototype;
+
+  _proto4.sendHandshakeReply = function sendHandshakeReply() {
+    var _this5 = this;
+
+    return new Postmate.Promise(function (resolve, reject) {
+      var shake = function shake(e) {
+        if (!e.data.postmate) {
+          return;
+        }
+
+        if (e.data.postmate === 'handshake') {
+          if (true) {
+            log('Child: Received handshake from Parent');
+          }
+
+          _this5.child.removeEventListener('message', shake, false);
+
+          if (true) {
+            log('Child: Sending handshake reply to Parent');
+          }
+
+          e.source.postMessage({
+            postmate: 'handshake-reply',
+            type: messageType
+          }, e.origin);
+          _this5.parentOrigin = e.origin; // Extend model with the one provided by the parent
+
+          var defaults = e.data.model;
+
+          if (defaults) {
+            Object.keys(defaults).forEach(function (key) {
+              _this5.model[key] = defaults[key];
+            });
+
+            if (true) {
+              log('Child: Inherited and extended model from Parent');
+            }
+          }
+
+          if (true) {
+            log('Child: Saving Parent origin', _this5.parentOrigin);
+          }
+
+          return resolve(new ChildAPI(_this5));
+        }
+
+        return reject('Handshake Reply Failed');
+      };
+
+      _this5.child.addEventListener('message', shake, false);
+    });
+  };
+
+  return Model;
+}();
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Postmate);
+
+
+/***/ }),
+
+/***/ "./node_modules/process/browser.js":
+/*!*****************************************!*\
+  !*** ./node_modules/process/browser.js ***!
+  \*****************************************/
+/***/ ((module) => {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+
+/***/ "./node_modules/snake-case/dist.es2015/index.js":
+/*!******************************************************!*\
+  !*** ./node_modules/snake-case/dist.es2015/index.js ***!
+  \******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "snakeCase": () => (/* binding */ snakeCase)
+/* harmony export */ });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
+/* harmony import */ var dot_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! dot-case */ "./node_modules/dot-case/dist.es2015/index.js");
+
+
+function snakeCase(input, options) {
+    if (options === void 0) { options = {}; }
+    return (0,dot_case__WEBPACK_IMPORTED_MODULE_0__.dotCase)(input, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__assign)({ delimiter: "_" }, options));
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./src/LSPlugin.caller.ts":
+/*!********************************!*\
+  !*** ./src/LSPlugin.caller.ts ***!
+  \********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "FLAG_AWAIT": () => (/* binding */ FLAG_AWAIT),
+/* harmony export */   "LSPMSG": () => (/* binding */ LSPMSG),
+/* harmony export */   "LSPMSG_ERROR_TAG": () => (/* binding */ LSPMSG_ERROR_TAG),
+/* harmony export */   "LSPMSG_SETTINGS": () => (/* binding */ LSPMSG_SETTINGS),
+/* harmony export */   "LSPMSG_BEFORE_UNLOAD": () => (/* binding */ LSPMSG_BEFORE_UNLOAD),
+/* harmony export */   "LSPMSG_SYNC": () => (/* binding */ LSPMSG_SYNC),
+/* harmony export */   "LSPMSG_READY": () => (/* binding */ LSPMSG_READY),
+/* harmony export */   "LSPMSGFn": () => (/* binding */ LSPMSGFn),
+/* harmony export */   "AWAIT_LSPMSGFn": () => (/* binding */ AWAIT_LSPMSGFn),
+/* harmony export */   "LSPluginCaller": () => (/* binding */ LSPluginCaller)
+/* harmony export */ });
+/* harmony import */ var postmate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! postmate */ "./node_modules/postmate/build/postmate.es.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js");
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(debug__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./helpers */ "./src/helpers.ts");
+/* harmony import */ var _LSPlugin_shadow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./LSPlugin.shadow */ "./src/LSPlugin.shadow.ts");
+
+
+
+
+
+const debug = debug__WEBPACK_IMPORTED_MODULE_2___default()('LSPlugin:caller');
+const FLAG_AWAIT = '#await#response#';
+const LSPMSG = '#lspmsg#';
+const LSPMSG_ERROR_TAG = '#lspmsg#error#';
+const LSPMSG_SETTINGS = '#lspmsg#settings#';
+const LSPMSG_BEFORE_UNLOAD = '#lspmsg#beforeunload#';
+const LSPMSG_SYNC = '#lspmsg#reply#';
+const LSPMSG_READY = '#lspmsg#ready#';
+const LSPMSGFn = (id) => `${LSPMSG}${id}`;
+const AWAIT_LSPMSGFn = (id) => `${FLAG_AWAIT}${id}`;
+/**
+ * Call between core and user
+ */
+class LSPluginCaller extends (eventemitter3__WEBPACK_IMPORTED_MODULE_1___default()) {
+    constructor(_pluginLocal) {
+        super();
+        this._pluginLocal = _pluginLocal;
+        this._connected = false;
+        this._userModel = {};
+        this._debugTag = '';
+        if (_pluginLocal) {
+            this._debugTag = _pluginLocal.debugTag;
+        }
+    }
+    async connectToChild() {
+        if (this._connected)
+            return;
+        const { shadow } = this._pluginLocal;
+        if (shadow) {
+            await this._setupShadowSandbox();
+        }
+        else {
+            await this._setupIframeSandbox();
+        }
+    }
+    async connectToParent(userModel = {}) {
+        if (this._connected)
+            return;
+        const caller = this;
+        const isShadowMode = this._pluginLocal != null;
+        let syncGCTimer = 0;
+        let syncTag = 0;
+        const syncActors = new Map();
+        const readyDeferred = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.deferred)(1000 * 5);
+        const model = this._extendUserModel({
+            [LSPMSG_READY]: async () => {
+                await readyDeferred.resolve();
+            },
+            [LSPMSG_BEFORE_UNLOAD]: async (e) => {
+                const actor = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.deferred)(10 * 1000);
+                caller.emit('beforeunload', Object.assign({ actor }, e));
+                await actor.promise;
+            },
+            [LSPMSG_SETTINGS]: async ({ type, payload }) => {
+                caller.emit('settings:changed', payload);
+            },
+            [LSPMSG]: async ({ ns, type, payload }) => {
+                debug(`${this._debugTag} [call from host]`, ns, type, payload);
+                if (ns && ns.startsWith('hook')) {
+                    caller.emit(`${ns}:${type}`, payload);
+                    return;
+                }
+                caller.emit(type, payload);
+            },
+            [LSPMSG_SYNC]: ({ _sync, result }) => {
+                debug(`sync reply #${_sync}`, result);
+                if (syncActors.has(_sync)) {
+                    const actor = syncActors.get(_sync);
+                    if (actor) {
+                        if (result?.hasOwnProperty(LSPMSG_ERROR_TAG)) {
+                            actor.reject(result[LSPMSG_ERROR_TAG]);
+                        }
+                        else {
+                            actor.resolve(result);
+                        }
+                        syncActors.delete(_sync);
+                    }
+                }
+            },
+            ...userModel
+        });
+        if (isShadowMode) {
+            await readyDeferred.promise;
+            return JSON.parse(JSON.stringify(this._pluginLocal?.toJSON()));
+        }
+        const handshake = new postmate__WEBPACK_IMPORTED_MODULE_0__.default.Model(model);
+        this._status = 'pending';
+        await handshake.then(refParent => {
+            this._child = refParent;
+            this._connected = true;
+            this._call = async (type, payload = {}, actor) => {
+                if (actor) {
+                    const tag = ++syncTag;
+                    syncActors.set(tag, actor);
+                    payload._sync = tag;
+                    actor.setTag(`async call #${tag}`);
+                    debug('async call #', tag);
+                }
+                refParent.emit(LSPMSGFn(model.baseInfo.id), { type, payload });
+                return actor?.promise;
+            };
+            this._callUserModel = async (type, payload) => {
+                try {
+                    model[type](payload);
+                }
+                catch (e) {
+                    debug(`model method #${type} not existed`);
+                }
+            };
+            // actors GC
+            syncGCTimer = setInterval(() => {
+                if (syncActors.size > 100) {
+                    for (const [k, v] of syncActors) {
+                        if (v.settled) {
+                            syncActors.delete(k);
+                        }
+                    }
+                }
+            }, 1000 * 60 * 30);
+        }).finally(() => {
+            this._status = undefined;
+        });
+        await readyDeferred.promise;
+        return model.baseInfo;
+    }
+    async call(type, payload = {}) {
+        return this._call?.call(this, type, payload);
+    }
+    async callAsync(type, payload = {}) {
+        const actor = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.deferred)(1000 * 10);
+        return this._call?.call(this, type, payload, actor);
+    }
+    async callUserModel(type, payload = {}) {
+        return this._callUserModel?.call(this, type, payload);
+    }
+    async _setupIframeSandbox() {
+        const pl = this._pluginLocal;
+        const handshake = new postmate__WEBPACK_IMPORTED_MODULE_0__.default({
+            container: document.body,
+            url: pl.options.entry,
+            classListArray: ['lsp-iframe-sandbox'],
+            model: { baseInfo: JSON.parse(JSON.stringify(pl.toJSON())) }
+        });
+        this._status = 'pending';
+        // timeout for handshake
+        let timer;
+        return new Promise((resolve, reject) => {
+            timer = setTimeout(() => {
+                reject(new Error(`handshake Timeout`));
+            }, 3 * 1000); // 3secs
+            handshake.then(refChild => {
+                this._parent = refChild;
+                this._connected = true;
+                this.emit('connected');
+                refChild.frame.setAttribute('id', pl.id);
+                refChild.on(LSPMSGFn(pl.id), ({ type, payload }) => {
+                    debug(`[call from plugin] `, type, payload);
+                    this._pluginLocal?.emit(type, payload || {});
+                });
+                this._call = async (...args) => {
+                    // parent all will get message before handshaked
+                    await refChild.call(LSPMSGFn(pl.id), { type: args[0], payload: args[1] || {} });
+                };
+                this._callUserModel = async (type, payload) => {
+                    if (type.startsWith(FLAG_AWAIT)) {
+                        // TODO: attach payload
+                        return await refChild.get(type.replace(FLAG_AWAIT, ''));
+                    }
+                    else {
+                        refChild.call(type, payload);
+                    }
+                };
+                resolve(null);
+            }).catch(e => {
+                reject(e);
+            }).finally(() => {
+                clearTimeout(timer);
+            });
+        }).catch(e => {
+            debug('iframe sandbox error', e);
+            throw e;
+        }).finally(() => {
+            this._status = undefined;
+        });
+    }
+    async _setupShadowSandbox() {
+        const pl = this._pluginLocal;
+        const shadow = this._shadow = new _LSPlugin_shadow__WEBPACK_IMPORTED_MODULE_4__.LSPluginShadowFrame(pl);
+        try {
+            this._status = 'pending';
+            await shadow.load();
+            this._connected = true;
+            this.emit('connected');
+            this._call = async (type, payload = {}, actor) => {
+                actor && (payload.actor = actor);
+                // TODO: support sync call
+                // @ts-ignore Call in same thread
+                this._pluginLocal?.emit(type, payload);
+                return actor?.promise;
+            };
+            this._callUserModel = async (...args) => {
+                let type = args[0];
+                if (type?.startsWith(FLAG_AWAIT)) {
+                    type = type.replace(FLAG_AWAIT, '');
+                }
+                const payload = args[1] || {};
+                const fn = this._userModel[type];
+                if (typeof fn === 'function') {
+                    await fn.call(null, payload);
+                }
+            };
+        }
+        catch (e) {
+            debug('shadow sandbox error', e);
+            throw e;
+        }
+        finally {
+            this._status = undefined;
+        }
+    }
+    _extendUserModel(model) {
+        return Object.assign(this._userModel, model);
+    }
+    _getSandboxIframeContainer() {
+        return this._parent?.frame;
+    }
+    _getSandboxShadowContainer() {
+        return this._shadow?.frame;
+    }
+    set debugTag(value) {
+        this._debugTag = value;
+    }
+    async destroy() {
+        if (this._parent) {
+            await this._parent.destroy();
+        }
+        if (this._shadow) {
+            this._shadow.destroy();
+        }
+    }
+}
+
+
+
+/***/ }),
+
+/***/ "./src/LSPlugin.shadow.ts":
+/*!********************************!*\
+  !*** ./src/LSPlugin.shadow.ts ***!
+  \********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "LSPluginShadowFrame": () => (/* binding */ LSPluginShadowFrame)
+/* harmony export */ });
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _LSPlugin_user__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./LSPlugin.user */ "./src/LSPlugin.user.ts");
+
+
+// @ts-ignore
+const { importHTML, createSandboxContainer } = window.QSandbox || {};
+function userFetch(url, opts) {
+    if (!url.startsWith('http')) {
+        url = url.replace('file://', '');
+        return new Promise(async (resolve, reject) => {
+            try {
+                const content = await window.apis.doAction(['readFile', url]);
+                resolve({
+                    text() {
+                        return content;
+                    }
+                });
+            }
+            catch (e) {
+                console.error(e);
+                reject(e);
+            }
+        });
+    }
+    return fetch(url, opts);
+}
+class LSPluginShadowFrame extends (eventemitter3__WEBPACK_IMPORTED_MODULE_0___default()) {
+    constructor(_pluginLocal) {
+        super();
+        this._pluginLocal = _pluginLocal;
+        this._loaded = false;
+        this._unmountFns = [];
+        _pluginLocal._dispose(() => {
+            this._unmount();
+        });
+    }
+    async load() {
+        const { name, entry } = this._pluginLocal.options;
+        if (this.loaded || !entry)
+            return;
+        const { template, execScripts } = await importHTML(entry, { fetch: userFetch });
+        this._mount(template, document.body);
+        const sandbox = createSandboxContainer(name, {
+            elementGetter: () => this._root?.firstChild,
+        });
+        const global = sandbox.instance.proxy;
+        global.__shadow_mode__ = true;
+        global.LSPluginLocal = this._pluginLocal;
+        global.LSPluginShadow = this;
+        global.LSPluginUser = global.logseq = new _LSPlugin_user__WEBPACK_IMPORTED_MODULE_1__.LSPluginUser(this._pluginLocal.toJSON(), this._pluginLocal.caller);
+        // TODO: {mount, unmount}
+        const execResult = await execScripts(global, true);
+        this._unmountFns.push(execResult.unmount);
+        this._loaded = true;
+    }
+    _mount(content, container) {
+        const frame = this._frame = document.createElement('div');
+        frame.classList.add('lsp-shadow-sandbox');
+        frame.id = this._pluginLocal.id;
+        this._root = frame.attachShadow({ mode: 'open' });
+        this._root.innerHTML = `<div>${content}</div>`;
+        container.appendChild(frame);
+        this.emit('mounted');
+    }
+    _unmount() {
+        for (const fn of this._unmountFns) {
+            fn && fn.call(null);
+        }
+    }
+    destroy() {
+        this.frame?.parentNode?.removeChild(this.frame);
+    }
+    get loaded() {
+        return this._loaded;
+    }
+    get document() {
+        return this._root?.firstChild;
+    }
+    get frame() {
+        return this._frame;
+    }
+}
+
+
+
+/***/ }),
+
+/***/ "./src/LSPlugin.user.ts":
+/*!******************************!*\
+  !*** ./src/LSPlugin.user.ts ***!
+  \******************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "LSPluginUser": () => (/* binding */ LSPluginUser),
+/* harmony export */   "setupPluginUserInstance": () => (/* binding */ setupPluginUserInstance)
+/* harmony export */ });
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./helpers */ "./src/helpers.ts");
+/* harmony import */ var _LSPlugin_caller__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./LSPlugin.caller */ "./src/LSPlugin.caller.ts");
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js");
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(debug__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var snake_case__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! snake-case */ "./node_modules/snake-case/dist.es2015/index.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_3__);
+
+
+
+
+
+const debug = debug__WEBPACK_IMPORTED_MODULE_2___default()('LSPlugin:user');
+const app = {};
+let registeredCmdUid = 0;
+const editor = {
+    registerSlashCommand(tag, actions) {
+        debug('Register slash command #', this.baseInfo.id, tag, actions);
+        if (typeof actions === 'function') {
+            actions = [
+                ['editor/clear-current-slash', false],
+                ['editor/restore-saved-cursor'],
+                ['editor/hook', actions]
+            ];
+        }
+        actions = actions.map((it) => {
+            const [tag, ...args] = it;
+            switch (tag) {
+                case 'editor/hook':
+                    let key = args[0];
+                    let fn = () => {
+                        this.caller?.callUserModel(key);
+                    };
+                    if (typeof key === 'function') {
+                        fn = key;
+                    }
+                    const eventKey = `SlashCommandHook${tag}${++registeredCmdUid}`;
+                    it[1] = eventKey;
+                    // register command listener
+                    this.Editor['on' + eventKey](fn);
+                    break;
+                default:
+            }
+            return it;
+        });
+        this.caller?.call(`api:call`, {
+            method: 'register-plugin-slash-command',
+            args: [this.baseInfo.id, [tag, actions]]
+        });
+        return false;
+    },
+    registerBlockContextMenu(tag, action) {
+        if (typeof action !== 'function') {
+            return false;
+        }
+        const key = tag;
+        const label = tag;
+        const type = 'block-context-menu';
+        const eventKey = `SimpleCommandHook${tag}${++registeredCmdUid}`;
+        this.Editor['on' + eventKey](action);
+        this.caller?.call(`api:call`, {
+            method: 'register-plugin-simple-command',
+            args: [this.baseInfo.id, [{ key, label, type }, ['editor/hook', eventKey]]]
+        });
+        return false;
+    }
+};
+const db = {};
+const KEY_MAIN_UI = 0;
+/**
+ * User plugin instance
+ */
+class LSPluginUser extends (eventemitter3__WEBPACK_IMPORTED_MODULE_3___default()) {
+    /**
+     * @param _baseInfo
+     * @param _caller
+     */
+    constructor(_baseInfo, _caller) {
+        super();
+        this._baseInfo = _baseInfo;
+        this._caller = _caller;
+        /**
+         * @private
+         */
+        this._connected = false;
+        /**
+         * ui frame identities
+         * @private
+         */
+        this._ui = new Map();
+        _caller.on('settings:changed', (payload) => {
+            const b = Object.assign({}, this.settings);
+            const a = Object.assign(this._baseInfo.settings, payload);
+            this.emit('settings:changed', { ...a }, b);
+        });
+        _caller.on('beforeunload', async (payload) => {
+            const { actor, ...rest } = payload;
+            const cb = this._beforeunloadCallback;
+            if (!cb || !actor)
+                return;
+            try {
+                cb && await cb(rest);
+                actor.resolve(null);
+            }
+            catch (e) {
+                console.debug(`${_caller.debugTag} [beforeunload] `, e);
+                actor.reject(e);
+            }
+        });
+    }
+    async ready(model, callback) {
+        if (this._connected)
+            return;
+        try {
+            if (typeof model === 'function') {
+                callback = model;
+                model = {};
+            }
+            let baseInfo = await this._caller.connectToParent(model);
+            baseInfo = (0,_helpers__WEBPACK_IMPORTED_MODULE_0__.deepMerge)(this._baseInfo, baseInfo);
+            this._connected = true;
+            if (baseInfo?.id) {
+                this._caller.debugTag = `#${baseInfo.id} [${baseInfo.name}]`;
+            }
+            callback && callback.call(this, baseInfo);
+        }
+        catch (e) {
+            console.error('[LSPlugin Ready Error]', e);
+        }
+    }
+    beforeunload(callback) {
+        if (typeof callback !== 'function')
+            return;
+        this._beforeunloadCallback = callback;
+    }
+    provideModel(model) {
+        this.caller._extendUserModel(model);
+        return this;
+    }
+    provideTheme(theme) {
+        this.caller.call('provider:theme', theme);
+        return this;
+    }
+    provideStyle(style) {
+        this.caller.call('provider:style', style);
+        return this;
+    }
+    provideUI(ui) {
+        this.caller.call('provider:ui', ui);
+        return this;
+    }
+    updateSettings(attrs) {
+        this.caller.call('settings:update', attrs);
+        // TODO: update associated baseInfo settings
+    }
+    setMainUIAttrs(attrs) {
+        this.caller.call('main-ui:attrs', attrs);
+    }
+    setMainUIInlineStyle(style) {
+        this.caller.call('main-ui:style', style);
+    }
+    hideMainUI(opts) {
+        const payload = { key: KEY_MAIN_UI, visible: false, cursor: opts?.restoreEditingCursor };
+        this.caller.call('main-ui:visible', payload);
+        this.emit('ui:visible:changed', payload);
+        this._ui.set(payload.key, payload);
+    }
+    showMainUI() {
+        const payload = { key: KEY_MAIN_UI, visible: true };
+        this.caller.call('main-ui:visible', payload);
+        this.emit('ui:visible:changed', payload);
+        this._ui.set(payload.key, payload);
+    }
+    toggleMainUI() {
+        const payload = { key: KEY_MAIN_UI, toggle: true };
+        const state = this._ui.get(payload.key);
+        if (state && state.visible) {
+            this.hideMainUI();
+        }
+        else {
+            this.showMainUI();
+        }
+    }
+    get isMainUIVisible() {
+        const state = this._ui.get(0);
+        return Boolean(state && state.visible);
+    }
+    get connected() {
+        return this._connected;
+    }
+    get baseInfo() {
+        return this._baseInfo;
+    }
+    get settings() {
+        return this.baseInfo?.settings;
+    }
+    get caller() {
+        return this._caller;
+    }
+    _makeUserProxy(target, tag) {
+        const that = this;
+        const caller = this.caller;
+        return new Proxy(target, {
+            get(target, propKey, receiver) {
+                const origMethod = target[propKey];
+                return function (...args) {
+                    if (origMethod) {
+                        const ret = origMethod.apply(that, args);
+                        if (ret === false)
+                            return;
+                    }
+                    // Handle hook
+                    if (tag) {
+                        const hookMatcher = propKey.toString().match(/^(once|off|on)/i);
+                        if (hookMatcher != null) {
+                            const f = hookMatcher[0].toLowerCase();
+                            const s = hookMatcher.input;
+                            const e = s.slice(f.length);
+                            const type = `hook:${tag}:${(0,snake_case__WEBPACK_IMPORTED_MODULE_4__.snakeCase)(e)}`;
+                            const handler = args[0];
+                            caller[f](type, handler);
+                            return f !== 'off' ? () => (caller.off(type, handler)) : void 0;
+                        }
+                    }
+                    // Call host
+                    return caller.callAsync(`api:call`, {
+                        method: propKey,
+                        args: args
+                    });
+                };
+            }
+        });
+    }
+    get App() {
+        return this._makeUserProxy(app, 'app');
+    }
+    get Editor() {
+        return this._makeUserProxy(editor, 'editor');
+    }
+    get DB() {
+        return this._makeUserProxy(db);
+    }
+}
+function setupPluginUserInstance(pluginBaseInfo, pluginCaller) {
+    return new LSPluginUser(pluginBaseInfo, pluginCaller);
+}
+if (window.__LSP__HOST__ == null) { // Entry of iframe mode
+    const caller = new _LSPlugin_caller__WEBPACK_IMPORTED_MODULE_1__.LSPluginCaller(null);
+    window.logseq = setupPluginUserInstance({}, caller);
+}
+
+
+/***/ }),
+
+/***/ "./src/helpers.ts":
+/*!************************!*\
+  !*** ./src/helpers.ts ***!
+  \************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "isObject": () => (/* binding */ isObject),
+/* harmony export */   "deepMerge": () => (/* binding */ deepMerge),
+/* harmony export */   "genID": () => (/* binding */ genID),
+/* harmony export */   "ucFirst": () => (/* binding */ ucFirst),
+/* harmony export */   "withFileProtocol": () => (/* binding */ withFileProtocol),
+/* harmony export */   "deferred": () => (/* binding */ deferred),
+/* harmony export */   "invokeHostExportedApi": () => (/* binding */ invokeHostExportedApi),
+/* harmony export */   "setupIframeSandbox": () => (/* binding */ setupIframeSandbox),
+/* harmony export */   "setupInjectedStyle": () => (/* binding */ setupInjectedStyle),
+/* harmony export */   "setupInjectedUI": () => (/* binding */ setupInjectedUI),
+/* harmony export */   "transformableEvent": () => (/* binding */ transformableEvent),
+/* harmony export */   "setupInjectedTheme": () => (/* binding */ setupInjectedTheme)
+/* harmony export */ });
+/* harmony import */ var snake_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! snake-case */ "./node_modules/snake-case/dist.es2015/index.js");
+
+function isObject(item) {
+    return (item === Object(item) && !Array.isArray(item));
+}
+function deepMerge(target, ...sources) {
+    // return the target if no sources passed
+    if (!sources.length) {
+        return target;
+    }
+    const result = target;
+    if (isObject(result)) {
+        const len = sources.length;
+        for (let i = 0; i < len; i += 1) {
+            const elm = sources[i];
+            if (isObject(elm)) {
+                for (const key in elm) {
+                    if (elm.hasOwnProperty(key)) {
+                        if (isObject(elm[key])) {
+                            if (!result[key] || !isObject(result[key])) {
+                                result[key] = {};
+                            }
+                            deepMerge(result[key], elm[key]);
+                        }
+                        else {
+                            if (Array.isArray(result[key]) && Array.isArray(elm[key])) {
+                                // concatenate the two arrays and remove any duplicate primitive values
+                                result[key] = Array.from(new Set(result[key].concat(elm[key])));
+                            }
+                            else {
+                                result[key] = elm[key];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+function genID() {
+    // Math.random should be unique because of its seeding algorithm.
+    // Convert it to base 36 (numbers + letters), and grab the first 9 characters
+    // after the decimal.
+    return '_' + Math.random().toString(36).substr(2, 9);
+}
+function ucFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function withFileProtocol(path) {
+    if (!path)
+        return '';
+    const reg = /^(http|file|assets)/;
+    if (!reg.test(path)) {
+        path = 'file://' + path;
+    }
+    return path;
+}
+/**
+ * @param timeout milliseconds
+ * @param tag string
+ */
+function deferred(timeout, tag) {
+    let resolve, reject;
+    let settled = false;
+    const timeFn = (r) => {
+        return (v) => {
+            timeout && clearTimeout(timeout);
+            r(v);
+            settled = true;
+        };
+    };
+    const promise = new Promise((resolve1, reject1) => {
+        resolve = timeFn(resolve1);
+        reject = timeFn(reject1);
+        if (timeout) {
+            // @ts-ignore
+            timeout = setTimeout(() => reject(new Error(`[deferred timeout] ${tag}`)), timeout);
+        }
+    });
+    return {
+        created: Date.now(),
+        setTag: (t) => tag = t,
+        resolve, reject, promise,
+        get settled() {
+            return settled;
+        }
+    };
+}
+function invokeHostExportedApi(method, ...args) {
+    const method1 = (0,snake_case__WEBPACK_IMPORTED_MODULE_0__.snakeCase)(method);
+    // @ts-ignore
+    const logseqHostExportedApi = window.logseq?.api || {};
+    const fn = logseqHostExportedApi[method1] || window.apis[method1] ||
+        logseqHostExportedApi[method] || window.apis[method];
+    if (!fn) {
+        throw new Error(`Not existed method #${method}`);
+    }
+    return typeof fn !== 'function' ? fn : fn.apply(null, args);
+}
+function setupIframeSandbox(props, target) {
+    const iframe = document.createElement('iframe');
+    iframe.classList.add('lsp-iframe-sandbox');
+    Object.entries(props).forEach(([k, v]) => {
+        iframe.setAttribute(k, v);
+    });
+    target.appendChild(iframe);
+    return async () => {
+        target.removeChild(iframe);
+    };
+}
+function setupInjectedStyle(style, attrs) {
+    const key = attrs['data-injected-style'];
+    let el = key && document.querySelector(`[data-injected-style=${key}]`);
+    if (el) {
+        el.textContent = style;
+        return;
+    }
+    el = document.createElement('style');
+    el.textContent = style;
+    attrs && Object.entries(attrs).forEach(([k, v]) => {
+        el.setAttribute(k, v);
+    });
+    document.head.append(el);
+    return () => {
+        document.head.removeChild(el);
+    };
+}
+function setupInjectedUI(ui, attrs) {
+    const pl = this;
+    let selector = '';
+    if ('slot' in ui) {
+        selector = `#${ui.slot}`;
+    }
+    else {
+        selector = ui.path;
+    }
+    const target = selector && document.querySelector(selector);
+    if (!target) {
+        console.error(`${this.debugTag} can not resolve selector target ${selector}`);
+        return;
+    }
+    const key = `${ui.key}-${pl.id}`;
+    let el = document.querySelector(`div[data-injected-ui="${key}"]`);
+    if (el) {
+        el.innerHTML = ui.template;
+        return;
+    }
+    el = document.createElement('div');
+    el.dataset.injectedUi = key || '';
+    // TODO: Support more
+    el.innerHTML = ui.template;
+    attrs && Object.entries(attrs).forEach(([k, v]) => {
+        el.setAttribute(k, v);
+    });
+    target.appendChild(el);
+    // TODO: How handle events
+    ['click', 'focus', 'focusin', 'focusout', 'blur', 'dblclick',
+        'keyup', 'keypress', 'keydown', 'change', 'input'].forEach((type) => {
+        el.addEventListener(type, (e) => {
+            const target = e.target;
+            const trigger = target.closest(`[data-on-${type}]`);
+            if (!trigger)
+                return;
+            const msgType = trigger.dataset[`on${ucFirst(type)}`];
+            msgType && pl.caller?.callUserModel(msgType, transformableEvent(trigger, e));
+        }, false);
+    });
+    return () => {
+        target.removeChild(el);
+    };
+}
+function transformableEvent(target, e) {
+    const obj = {};
+    if (target) {
+        const ds = target.dataset;
+        const FLAG_RECT = 'rect';
+        ['value', 'id', 'className',
+            'dataset', FLAG_RECT
+        ].forEach((k) => {
+            let v;
+            switch (k) {
+                case FLAG_RECT:
+                    if (!ds.hasOwnProperty(FLAG_RECT))
+                        return;
+                    v = target.getBoundingClientRect().toJSON();
+                    break;
+                default:
+                    v = target[k];
+            }
+            if (typeof v === 'object') {
+                v = { ...v };
+            }
+            obj[k] = v;
+        });
+    }
+    return obj;
+}
+let injectedThemeEffect = null;
+function setupInjectedTheme(url) {
+    injectedThemeEffect?.call();
+    if (!url)
+        return;
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    document.head.appendChild(link);
+    return (injectedThemeEffect = () => {
+        document.head.removeChild(link);
+        injectedThemeEffect = null;
+    });
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/tslib/tslib.es6.js":
+/*!*****************************************!*\
+  !*** ./node_modules/tslib/tslib.es6.js ***!
+  \*****************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "__extends": () => (/* binding */ __extends),
+/* harmony export */   "__assign": () => (/* binding */ __assign),
+/* harmony export */   "__rest": () => (/* binding */ __rest),
+/* harmony export */   "__decorate": () => (/* binding */ __decorate),
+/* harmony export */   "__param": () => (/* binding */ __param),
+/* harmony export */   "__metadata": () => (/* binding */ __metadata),
+/* harmony export */   "__awaiter": () => (/* binding */ __awaiter),
+/* harmony export */   "__generator": () => (/* binding */ __generator),
+/* harmony export */   "__createBinding": () => (/* binding */ __createBinding),
+/* harmony export */   "__exportStar": () => (/* binding */ __exportStar),
+/* harmony export */   "__values": () => (/* binding */ __values),
+/* harmony export */   "__read": () => (/* binding */ __read),
+/* harmony export */   "__spread": () => (/* binding */ __spread),
+/* harmony export */   "__spreadArrays": () => (/* binding */ __spreadArrays),
+/* harmony export */   "__spreadArray": () => (/* binding */ __spreadArray),
+/* harmony export */   "__await": () => (/* binding */ __await),
+/* harmony export */   "__asyncGenerator": () => (/* binding */ __asyncGenerator),
+/* harmony export */   "__asyncDelegator": () => (/* binding */ __asyncDelegator),
+/* harmony export */   "__asyncValues": () => (/* binding */ __asyncValues),
+/* harmony export */   "__makeTemplateObject": () => (/* binding */ __makeTemplateObject),
+/* harmony export */   "__importStar": () => (/* binding */ __importStar),
+/* harmony export */   "__importDefault": () => (/* binding */ __importDefault),
+/* harmony export */   "__classPrivateFieldGet": () => (/* binding */ __classPrivateFieldGet),
+/* harmony export */   "__classPrivateFieldSet": () => (/* binding */ __classPrivateFieldSet)
+/* harmony export */ });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        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)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, 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 ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, 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 (_) try {
+            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;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+function __spreadArray(to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+var __setModuleDefault = Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/util/support/isBufferBrowser.js":
+/*!******************************************************!*\
+  !*** ./node_modules/util/support/isBufferBrowser.js ***!
+  \******************************************************/
+/***/ ((module) => {
+
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+
+/***/ }),
+
+/***/ "./node_modules/util/util.js":
+/*!***********************************!*\
+  !*** ./node_modules/util/util.js ***!
+  \***********************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(__webpack_require__.g.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = __webpack_require__(/*! ./support/isBuffer */ "./node_modules/util/support/isBufferBrowser.js");
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(() => {
+"use strict";
+/*!******************************!*\
+  !*** ./src/LSPlugin.core.ts ***!
+  \******************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "PluginLocal": () => (/* binding */ PluginLocal),
+/* harmony export */   "setupPluginCore": () => (/* binding */ setupPluginCore)
+/* harmony export */ });
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
+/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./helpers */ "./src/helpers.ts");
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js");
+/* harmony import */ var debug__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(debug__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./LSPlugin.caller */ "./src/LSPlugin.caller.ts");
+/* harmony import */ var snake_case__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! snake-case */ "./node_modules/snake-case/dist.es2015/index.js");
+/* harmony import */ var dompurify__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! dompurify */ "./node_modules/dompurify/dist/purify.js");
+/* harmony import */ var dompurify__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(dompurify__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! path */ "./node_modules/path/path.js");
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_5__);
+
+
+
+
+
+
+
+const debug = debug__WEBPACK_IMPORTED_MODULE_2___default()('LSPlugin:core');
+/**
+ * User settings
+ */
+class PluginSettings extends (eventemitter3__WEBPACK_IMPORTED_MODULE_0___default()) {
+    constructor(_userPluginSettings) {
+        super();
+        this._userPluginSettings = _userPluginSettings;
+        this._settings = {
+            disabled: false
+        };
+        Object.assign(this._settings, _userPluginSettings);
+    }
+    get(k) {
+        return this._settings[k];
+    }
+    set(k, v) {
+        const o = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.deepMerge)({}, this._settings);
+        if (typeof k === 'string') {
+            if (this._settings[k] == v)
+                return;
+            this._settings[k] = v;
+        }
+        else if ((0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isObject)(k)) {
+            (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.deepMerge)(this._settings, k);
+        }
+        else {
+            return;
+        }
+        this.emit('change', Object.assign({}, this._settings), o);
+    }
+    toJSON() {
+        return this._settings;
+    }
+}
+class PluginLogger extends (eventemitter3__WEBPACK_IMPORTED_MODULE_0___default()) {
+    constructor(_tag) {
+        super();
+        this._tag = _tag;
+        this._logs = [];
+    }
+    write(type, payload) {
+        let msg = payload.reduce((ac, it) => {
+            if (it && it instanceof Error) {
+                ac += `${it.message} ${it.stack}`;
+            }
+            else {
+                ac += it.toString();
+            }
+            return ac;
+        }, `[${this._tag}][${new Date().toLocaleTimeString()}] `);
+        this._logs.push([type, msg]);
+        this.emit('change');
+    }
+    clear() {
+        this._logs = [];
+        this.emit('change');
+    }
+    info(...args) {
+        this.write('INFO', args);
+    }
+    error(...args) {
+        this.write('ERROR', args);
+    }
+    warn(...args) {
+        this.write('WARN', args);
+    }
+    toJSON() {
+        return this._logs;
+    }
+}
+var PluginLocalLoadStatus;
+(function (PluginLocalLoadStatus) {
+    PluginLocalLoadStatus["LOADING"] = "loading";
+    PluginLocalLoadStatus["UNLOADING"] = "unloading";
+    PluginLocalLoadStatus["LOADED"] = "loaded";
+    PluginLocalLoadStatus["UNLOADED"] = "unload";
+    PluginLocalLoadStatus["ERROR"] = "error";
+})(PluginLocalLoadStatus || (PluginLocalLoadStatus = {}));
+function initUserSettingsHandlers(pluginLocal) {
+    const _ = (label) => `settings:${label}`;
+    pluginLocal.on(_('update'), (attrs) => {
+        if (!attrs)
+            return;
+        pluginLocal.settings?.set(attrs);
+    });
+}
+function initMainUIHandlers(pluginLocal) {
+    const _ = (label) => `main-ui:${label}`;
+    pluginLocal.on(_('visible'), ({ visible, toggle, cursor }) => {
+        const el = pluginLocal.getMainUI();
+        el?.classList[toggle ? 'toggle' : (visible ? 'add' : 'remove')]('visible');
+        // pluginLocal.caller!.callUserModel(LSPMSG, { type: _('visible'), payload: visible })
+        // auto focus frame
+        if (visible) {
+            if (!pluginLocal.shadow && el) {
+                el.contentWindow?.focus();
+            }
+        }
+        if (cursor) {
+            (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('restore_editing_cursor');
+        }
+    });
+    pluginLocal.on(_('attrs'), (attrs) => {
+        const el = pluginLocal.getMainUI();
+        Object.entries(attrs).forEach(([k, v]) => {
+            el?.setAttribute(k, v);
+        });
+    });
+    pluginLocal.on(_('style'), (style) => {
+        const el = pluginLocal.getMainUI();
+        Object.entries(style).forEach(([k, v]) => {
+            el.style[k] = v;
+        });
+    });
+}
+function initProviderHandlers(pluginLocal) {
+    let _ = (label) => `provider:${label}`;
+    let themed = false;
+    pluginLocal.on(_('theme'), (theme) => {
+        pluginLocal.themeMgr.registerTheme(pluginLocal.id, theme);
+        if (!themed) {
+            pluginLocal._dispose(() => {
+                pluginLocal.themeMgr.unregisterTheme(pluginLocal.id);
+            });
+            themed = true;
+        }
+    });
+    pluginLocal.on(_('style'), (style) => {
+        let key;
+        if (typeof style !== 'string') {
+            key = style.key;
+            style = style.style;
+        }
+        if (!style || !style.trim())
+            return;
+        pluginLocal._dispose((0,_helpers__WEBPACK_IMPORTED_MODULE_1__.setupInjectedStyle)(style, {
+            'data-injected-style': key ? `${key}-${pluginLocal.id}` : '',
+            'data-ref': pluginLocal.id
+        }));
+    });
+    pluginLocal.on(_('ui'), (ui) => {
+        pluginLocal._onHostMounted(() => {
+            // safe template
+            ui.template = dompurify__WEBPACK_IMPORTED_MODULE_4___default().sanitize(ui.template);
+            pluginLocal._dispose(_helpers__WEBPACK_IMPORTED_MODULE_1__.setupInjectedUI.call(pluginLocal, ui, {
+                'data-ref': pluginLocal.id
+            }));
+        });
+    });
+}
+function initApiProxyHandlers(pluginLocal) {
+    let _ = (label) => `api:${label}`;
+    pluginLocal.on(_('call'), async (payload) => {
+        let ret;
+        try {
+            ret = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)(payload.method, ...payload.args);
+        }
+        catch (e) {
+            ret = {
+                [_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG_ERROR_TAG]: e,
+            };
+        }
+        const { _sync } = payload;
+        if (pluginLocal.shadow) {
+            if (payload.actor) {
+                payload.actor.resolve(ret);
+            }
+            return;
+        }
+        if (_sync != null) {
+            const reply = (result) => {
+                pluginLocal.caller?.callUserModel(_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG_SYNC, {
+                    result, _sync
+                });
+            };
+            Promise.resolve(ret).then(reply, reply);
+        }
+    });
+}
+class IllegalPluginPackageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = IllegalPluginPackageError.name;
+    }
+}
+class ExistedImportedPluginPackageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = ExistedImportedPluginPackageError.name;
+    }
+}
+/**
+ * Host plugin for local
+ */
+class PluginLocal extends (eventemitter3__WEBPACK_IMPORTED_MODULE_0___default()) {
+    /**
+     * @param _options
+     * @param _themeMgr
+     * @param _ctx
+     */
+    constructor(_options, _themeMgr, _ctx) {
+        super();
+        this._options = _options;
+        this._themeMgr = _themeMgr;
+        this._ctx = _ctx;
+        this._disposes = [];
+        this._status = PluginLocalLoadStatus.UNLOADED;
+        this._id = _options.key || (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.genID)();
+        initUserSettingsHandlers(this);
+        initMainUIHandlers(this);
+        initProviderHandlers(this);
+        initApiProxyHandlers(this);
+    }
+    async _setupUserSettings() {
+        const { _options } = this;
+        const key = _options.name.replace(/[^a-z0-9]/gi, '_').toLowerCase() + '_' + this.id;
+        const logger = _options.logger = new PluginLogger('Loader');
+        try {
+            const [userSettingsFilePath, userSettings] = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('load_plugin_user_settings', key);
+            this._userSettingsFile = userSettingsFilePath;
+            const settings = _options.settings = new PluginSettings(userSettings);
+            // observe settings
+            settings.on('change', (a, b) => {
+                debug('linked settings change', a);
+                if (!a.disabled && b.disabled) {
+                    // Enable plugin
+                    this.load();
+                }
+                if (a.disabled && !b.disabled) {
+                    // Disable plugin
+                    this.unload();
+                }
+                if (a) {
+                    (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)(`save_plugin_user_settings`, key, a);
+                }
+            });
+        }
+        catch (e) {
+            debug('[load plugin user settings Error]', e);
+            logger?.error(e);
+        }
+    }
+    getMainUI() {
+        if (this.shadow) {
+            return this.caller?._getSandboxShadowContainer();
+        }
+        return this.caller?._getSandboxIframeContainer();
+    }
+    async _preparePackageConfigs() {
+        const { url } = this._options;
+        let pkg;
+        try {
+            if (!url) {
+                throw new Error('Can not resolve package config location');
+            }
+            debug('prepare package root', url);
+            pkg = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('load_plugin_config', url);
+            if (!pkg || (pkg = JSON.parse(pkg), !pkg)) {
+                throw new Error(`Parse package config error #${url}/package.json`);
+            }
+        }
+        catch (e) {
+            throw new IllegalPluginPackageError(e.message);
+        }
+        // Pick legal attrs
+        ['name', 'author', 'repository', 'version', 'description'].forEach(k => {
+            this._options[k] = pkg[k];
+        });
+        // TODO: How with local protocol
+        const localRoot = this._localRoot = url;
+        const logseq = pkg.logseq || {};
+        const makeFullUrl = (loc, useFileProtocol = false) => {
+            if (!loc)
+                return;
+            const reg = /^(http|file|assets)/;
+            if (!reg.test(loc)) {
+                const url = path__WEBPACK_IMPORTED_MODULE_5__.join(localRoot, loc);
+                loc = reg.test(url) ? url : ('file://' + url);
+            }
+            return useFileProtocol ? loc : loc.replace('file:', 'assets:');
+        };
+        const validateMain = (main) => main && /\.(js|html)$/.test(main);
+        // Entry from main
+        if (validateMain(pkg.main)) {
+            this._options.entry = makeFullUrl(pkg.main, true);
+            if (logseq.mode) {
+                this._options.mode = logseq.mode;
+            }
+        }
+        const icon = logseq.icon || pkg.icon;
+        if (icon) {
+            this._options.icon = makeFullUrl(icon);
+        }
+        // TODO: strategy for Logseq plugins center
+        if (logseq.id) {
+            this._id = logseq.id;
+        }
+        else {
+            logseq.id = this.id;
+            try {
+                await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('save_plugin_config', url, { ...pkg, logseq });
+            }
+            catch (e) {
+                debug('[save plugin ID Error] ', e);
+            }
+        }
+        // Validate id
+        const { registeredPlugins, isRegistering } = this._ctx;
+        if (isRegistering && registeredPlugins.has(logseq.id)) {
+            throw new ExistedImportedPluginPackageError('prepare package Error');
+        }
+        return async () => {
+            try {
+                // 0. Install Themes
+                let themes = logseq.themes;
+                if (themes) {
+                    await this._loadConfigThemes(Array.isArray(themes) ? themes : [themes]);
+                }
+            }
+            catch (e) {
+                debug('[prepare package effect Error]', e);
+            }
+        };
+    }
+    async _tryToNormalizeEntry() {
+        let { entry, settings } = this.options;
+        let devEntry = settings?.get('_devEntry');
+        if (devEntry) {
+            this._options.entry = devEntry;
+            return;
+        }
+        if (!entry.endsWith('.js'))
+            return;
+        let sdkPath = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('_callApplication', 'getAppPath');
+        let entryPath = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)('write_user_tmp_file', `${this._id}_index.html`, `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>logseq plugin entry</title>
+    <script src="${sdkPath}/js/lsplugin.user.js"></script>
+  </head>
+  <body>
+  <div id="app"></div>
+  <script src="${entry}"></script>
+  </body>
+</html>`);
+        this._options.entry = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.withFileProtocol)(entryPath);
+    }
+    async _loadConfigThemes(themes) {
+        themes.forEach((options) => {
+            if (!options.url)
+                return;
+            if (!options.url.startsWith('http') && this._localRoot) {
+                options.url = path__WEBPACK_IMPORTED_MODULE_5__.join(this._localRoot, options.url);
+                // file:// for native
+                if (!options.url.startsWith('file:')) {
+                    options.url = 'assets://' + options.url;
+                }
+            }
+            // @ts-ignore
+            this.emit('provider:theme', options);
+        });
+    }
+    async load(readyIndicator) {
+        if (this.pending) {
+            return;
+        }
+        this._status = PluginLocalLoadStatus.LOADING;
+        this._loadErr = undefined;
+        try {
+            let installPackageThemes = () => Promise.resolve();
+            if (!this.options.entry) { // Themes package no entry field
+                installPackageThemes = await this._preparePackageConfigs();
+            }
+            if (!this.settings) {
+                await this._setupUserSettings();
+            }
+            if (!this.disabled) {
+                await installPackageThemes.call(null);
+            }
+            if (this.disabled || !this.options.entry) {
+                return;
+            }
+            await this._tryToNormalizeEntry();
+            this._caller = new _LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPluginCaller(this);
+            await this._caller.connectToChild();
+            const readyFn = () => {
+                this._caller?.callUserModel(_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG_READY);
+            };
+            if (readyIndicator) {
+                readyIndicator.promise.then(readyFn);
+            }
+            else {
+                readyFn();
+            }
+            this._disposes.push(async () => {
+                await this._caller?.destroy();
+            });
+        }
+        catch (e) {
+            debug('[Load Plugin Error] ', e);
+            this.logger?.error(e);
+            this._status = PluginLocalLoadStatus.ERROR;
+            this._loadErr = e;
+        }
+        finally {
+            if (!this._loadErr) {
+                this._status = PluginLocalLoadStatus.LOADED;
+            }
+        }
+    }
+    async reload() {
+        debug('TODO: reload plugin', this.id);
+    }
+    /**
+     * @param unregister If true delete plugin files
+     */
+    async unload(unregister = false) {
+        if (this.pending) {
+            return;
+        }
+        if (unregister) {
+            await this.unload();
+            if (this.isInstalledInUserRoot) {
+                debug('TODO: remove plugin local files from user home root :)');
+            }
+            return;
+        }
+        try {
+            this._status = PluginLocalLoadStatus.UNLOADING;
+            const eventBeforeUnload = { unregister };
+            // sync call
+            try {
+                await this._caller?.callUserModel((0,_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.AWAIT_LSPMSGFn)(_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG_BEFORE_UNLOAD), eventBeforeUnload);
+                this.emit('beforeunload', eventBeforeUnload);
+            }
+            catch (e) {
+                console.error('[beforeunload Error]', e);
+            }
+            await this.dispose();
+            this.emit('unloaded');
+        }
+        catch (e) {
+            debug('[plugin unload Error]', e);
+        }
+        finally {
+            this._status = PluginLocalLoadStatus.UNLOADED;
+        }
+    }
+    async dispose() {
+        for (const fn of this._disposes) {
+            try {
+                fn && (await fn());
+            }
+            catch (e) {
+                console.error(this.debugTag, 'dispose Error', e);
+            }
+        }
+        // clear
+        this._disposes = [];
+    }
+    _dispose(fn) {
+        if (!fn)
+            return;
+        this._disposes.push(fn);
+    }
+    _onHostMounted(callback) {
+        const actor = this._ctx.hostMountedActor;
+        if (!actor || actor.settled) {
+            callback();
+        }
+        else {
+            actor?.promise.then(callback);
+        }
+    }
+    get isInstalledInUserRoot() {
+        const userRoot = this._ctx.options.localUserConfigRoot;
+        const plugRoot = this._localRoot;
+        return userRoot && plugRoot && plugRoot.startsWith(userRoot);
+    }
+    get loaded() {
+        return this._status === PluginLocalLoadStatus.LOADED;
+    }
+    get pending() {
+        return [PluginLocalLoadStatus.LOADING, PluginLocalLoadStatus.UNLOADING]
+            .includes(this._status);
+    }
+    get status() {
+        return this._status;
+    }
+    get settings() {
+        return this.options.settings;
+    }
+    get logger() {
+        return this.options.logger;
+    }
+    get disabled() {
+        return this.settings?.get('disabled');
+    }
+    get caller() {
+        return this._caller;
+    }
+    get id() {
+        return this._id;
+    }
+    get shadow() {
+        return this.options.mode === 'shadow';
+    }
+    get options() {
+        return this._options;
+    }
+    get themeMgr() {
+        return this._themeMgr;
+    }
+    get debugTag() {
+        const name = this._options?.name;
+        return `#${this._id} ${name ?? ''}`;
+    }
+    get localRoot() {
+        return this._localRoot || this._options.url;
+    }
+    get loadErr() {
+        return this._loadErr;
+    }
+    get userSettingsFile() {
+        return this._userSettingsFile;
+    }
+    toJSON() {
+        const json = { ...this.options };
+        json.id = this.id;
+        json.err = this.loadErr;
+        json.usf = this.userSettingsFile;
+        return json;
+    }
+}
+/**
+ * Host plugin core
+ */
+class LSPluginCore extends (eventemitter3__WEBPACK_IMPORTED_MODULE_0___default()) {
+    /**
+     * @param _options
+     */
+    constructor(_options) {
+        super();
+        this._options = _options;
+        this._isRegistering = false;
+        this._hostMountedActor = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.deferred)();
+        this._userPreferences = {};
+        this._registeredThemes = new Map();
+        this._registeredPlugins = new Map();
+    }
+    async loadUserPreferences() {
+        try {
+            const settings = await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)(`load_user_preferences`);
+            if (settings) {
+                Object.assign(this._userPreferences, settings);
+            }
+        }
+        catch (e) {
+            debug('[load user preferences Error]', e);
+        }
+    }
+    async saveUserPreferences(settings) {
+        try {
+            if (settings) {
+                Object.assign(this._userPreferences, settings);
+            }
+            await (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.invokeHostExportedApi)(`save_user_preferences`, this._userPreferences);
+        }
+        catch (e) {
+            debug('[save user preferences Error]', e);
+        }
+    }
+    async activateUserPreferences() {
+        const { theme } = this._userPreferences;
+        // 0. theme
+        if (theme) {
+            await this.selectTheme(theme, false);
+        }
+    }
+    /**
+     * @param plugins
+     * @param initial
+     */
+    async register(plugins, initial = false) {
+        if (!Array.isArray(plugins)) {
+            await this.register([plugins]);
+            return;
+        }
+        try {
+            this._isRegistering = true;
+            const userConfigRoot = this._options.localUserConfigRoot;
+            const readyIndicator = this._readyIndicator = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.deferred)();
+            await this.loadUserPreferences();
+            const externals = new Set(this._userPreferences.externals || []);
+            if (initial) {
+                plugins = plugins.concat([...externals].filter(url => {
+                    return !plugins.length || plugins.every((p) => !p.entry && (p.url !== url));
+                }).map(url => ({ url })));
+            }
+            for (const pluginOptions of plugins) {
+                const { url } = pluginOptions;
+                const pluginLocal = new PluginLocal(pluginOptions, this, this);
+                const timeLabel = `[LOAD Plugin] ${pluginLocal.debugTag}`;
+                console.time(timeLabel);
+                await pluginLocal.load(readyIndicator);
+                const { loadErr } = pluginLocal;
+                if (loadErr) {
+                    debug(`[Failed LOAD Plugin] #`, pluginOptions);
+                    this.emit('error', loadErr);
+                    if (loadErr instanceof IllegalPluginPackageError ||
+                        loadErr instanceof ExistedImportedPluginPackageError) {
+                        // TODO: notify global log system?
+                        continue;
+                    }
+                }
+                console.timeEnd(timeLabel);
+                pluginLocal.settings?.on('change', (a) => {
+                    this.emit('settings-changed', pluginLocal.id, a);
+                    pluginLocal.caller?.callUserModel(_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG_SETTINGS, { payload: a });
+                });
+                this._registeredPlugins.set(pluginLocal.id, pluginLocal);
+                this.emit('registered', pluginLocal);
+                // external plugins
+                if (!pluginLocal.isInstalledInUserRoot) {
+                    externals.add(url);
+                }
+            }
+            await this.saveUserPreferences({ externals: Array.from(externals) });
+            await this.activateUserPreferences();
+            readyIndicator.resolve('ready');
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this._isRegistering = false;
+        }
+    }
+    async reload(plugins) {
+        if (!Array.isArray(plugins)) {
+            await this.reload([plugins]);
+            return;
+        }
+        for (const identity of plugins) {
+            const p = this.ensurePlugin(identity);
+            await p.reload();
+        }
+    }
+    async unregister(plugins) {
+        if (!Array.isArray(plugins)) {
+            await this.unregister([plugins]);
+            return;
+        }
+        const unregisteredExternals = [];
+        for (const identity of plugins) {
+            const p = this.ensurePlugin(identity);
+            if (!p.isInstalledInUserRoot) {
+                unregisteredExternals.push(p.options.url);
+            }
+            await p.unload(true);
+            this._registeredPlugins.delete(identity);
+            this.emit('unregistered', identity);
+        }
+        let externals = this._userPreferences.externals || [];
+        if (externals.length && unregisteredExternals.length) {
+            await this.saveUserPreferences({
+                externals: externals.filter((it) => {
+                    return !unregisteredExternals.includes(it);
+                })
+            });
+        }
+    }
+    async enable(plugin) {
+        const p = this.ensurePlugin(plugin);
+        if (p.pending)
+            return;
+        this.emit('beforeenable');
+        p.settings?.set('disabled', false);
+        // this.emit('enabled', p)
+    }
+    async disable(plugin) {
+        const p = this.ensurePlugin(plugin);
+        if (p.pending)
+            return;
+        this.emit('beforedisable');
+        p.settings?.set('disabled', true);
+        // this.emit('disabled', p)
+    }
+    async _hook(ns, type, payload, pid) {
+        for (const [_, p] of this._registeredPlugins) {
+            if (!pid || pid === p.id) {
+                p.caller?.callUserModel(_LSPlugin_caller__WEBPACK_IMPORTED_MODULE_3__.LSPMSG, {
+                    ns, type: (0,snake_case__WEBPACK_IMPORTED_MODULE_6__.snakeCase)(type), payload
+                });
+            }
+        }
+    }
+    hookApp(type, payload, pid) {
+        this._hook(`hook:app`, type, payload, pid);
+    }
+    hookEditor(type, payload, pid) {
+        this._hook(`hook:editor`, type, payload, pid);
+    }
+    _execDirective(tag, ...params) {
+    }
+    ensurePlugin(plugin) {
+        if (plugin instanceof PluginLocal) {
+            return plugin;
+        }
+        const p = this._registeredPlugins.get(plugin);
+        if (!p) {
+            throw new Error(`plugin #${plugin} not existed.`);
+        }
+        return p;
+    }
+    hostMounted() {
+        this._hostMountedActor.resolve();
+    }
+    get registeredPlugins() {
+        return this._registeredPlugins;
+    }
+    get options() {
+        return this._options;
+    }
+    get readyIndicator() {
+        return this._readyIndicator;
+    }
+    get hostMountedActor() {
+        return this._hostMountedActor;
+    }
+    get isRegistering() {
+        return this._isRegistering;
+    }
+    get themes() {
+        return this._registeredThemes;
+    }
+    async registerTheme(id, opt) {
+        debug('registered Theme #', id, opt);
+        if (!id)
+            return;
+        let themes = this._registeredThemes.get(id);
+        if (!themes) {
+            this._registeredThemes.set(id, themes = []);
+        }
+        themes.push(opt);
+        this.emit('theme-changed', this.themes, { id, ...opt });
+    }
+    async selectTheme(opt, effect = true) {
+        (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.setupInjectedTheme)(opt?.url);
+        this.emit('theme-selected', opt);
+        effect && this.saveUserPreferences({ theme: opt });
+    }
+    async unregisterTheme(id) {
+        debug('unregistered Theme #', id);
+        if (!this._registeredThemes.has(id))
+            return;
+        this._registeredThemes.delete(id);
+        this.emit('theme-changed', this.themes, { id });
+    }
+}
+function setupPluginCore(options) {
+    const pluginCore = new LSPluginCore(options);
+    debug('=== 🔗 Setup Logseq Plugin System 🔗 ===');
+    window.LSPluginCore = pluginCore;
+}
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://LSPlugin/webpack/universalModuleDefinition","webpack://LSPlugin/./node_modules/debug/src/browser.js","webpack://LSPlugin/./node_modules/debug/src/common.js","webpack://LSPlugin/./node_modules/dompurify/dist/purify.js","webpack://LSPlugin/./node_modules/dot-case/dist.es2015/index.js","webpack://LSPlugin/./node_modules/eventemitter3/index.js","webpack://LSPlugin/./node_modules/inherits/inherits_browser.js","webpack://LSPlugin/./node_modules/lower-case/dist.es2015/index.js","webpack://LSPlugin/./node_modules/ms/index.js","webpack://LSPlugin/./node_modules/no-case/dist.es2015/index.js","webpack://LSPlugin/./node_modules/path/path.js","webpack://LSPlugin/./node_modules/postmate/build/postmate.es.js","webpack://LSPlugin/./node_modules/process/browser.js","webpack://LSPlugin/./node_modules/snake-case/dist.es2015/index.js","webpack://LSPlugin/./src/LSPlugin.caller.ts","webpack://LSPlugin/./src/LSPlugin.shadow.ts","webpack://LSPlugin/./src/LSPlugin.user.ts","webpack://LSPlugin/./src/helpers.ts","webpack://LSPlugin/./node_modules/tslib/tslib.es6.js","webpack://LSPlugin/./node_modules/util/support/isBufferBrowser.js","webpack://LSPlugin/./node_modules/util/util.js","webpack://LSPlugin/webpack/bootstrap","webpack://LSPlugin/webpack/runtime/compat get default export","webpack://LSPlugin/webpack/runtime/define property getters","webpack://LSPlugin/webpack/runtime/global","webpack://LSPlugin/webpack/runtime/hasOwnProperty shorthand","webpack://LSPlugin/webpack/runtime/make namespace object","webpack://LSPlugin/./src/LSPlugin.core.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;;;;;;;;;;ACVA;;AAEA;AACA;AACA;;AAEA,kBAAkB;AAClB,YAAY;AACZ,YAAY;AACZ,iBAAiB;AACjB,eAAe;AACf,eAAe;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;;AAEA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,4CAA4C;;AAEvD;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;;AAEA;AACA,kBAAkB,OAAO,6BAA6B,OAAO;AAC7D,MAAM,OAAO;AACb;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA,iBAAiB,mBAAO,CAAC,oDAAU;;AAEnC,OAAO,WAAW;;AAElB;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;;;;;;;;;;;;AC3QA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,mBAAO,CAAC,sCAAI;AACpC;;AAEA;AACA;AACA,EAAE;;AAEF;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,YAAY,cAAc;AAC1B;AACA;AACA;AACA;;AAEA,iBAAiB,sBAAsB;AACvC;AACA,aAAa;AACb;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI;;AAEJ;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,sCAAsC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,6CAA6C,SAAS;AACtD;AACA;AACA;AACA;;AAEA,6CAA6C,SAAS;AACtD;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACpQA;;AAEA;AACA,EAAE,KAA4D;AAC9D,EAAE,CACuD;AACzD,CAAC,oBAAoB;;AAErB,oCAAoC,0BAA0B,0CAA0C,gBAAgB,OAAO,kBAAkB,EAAE,aAAa,EAAE,OAAO,wBAAwB,EAAE;;AAEnM;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;;AAE7B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,wFAAwF,aAAa;AACrG;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,wEAAwE,eAAe;AACvF;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,8BAA8B,EAAE,iBAAiB,EAAE,KAAK;AACxD;AACA,qDAAqD;AACrD,yCAAyC;AACzC;AACA;AACA;AACA;AACA;;AAEA,sGAAsG,mBAAmB,EAAE,mBAAmB,8HAA8H;;AAE5Q,sCAAsC,0BAA0B,0CAA0C,gBAAgB,OAAO,kBAAkB,EAAE,aAAa,EAAE,OAAO,wBAAwB,EAAE;;AAErM;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,0BAA0B;AACvC,aAAa,SAAS;AACtB,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,KAAK;;AAEL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,0CAA0C;;AAE1C;AACA;AACA,0CAA0C;;AAE1C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,qCAAqC;;AAErC;AACA;AACA,2CAA2C;;AAE3C;AACA;AACA,iDAAiD;;AAEjD;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,wDAAwD;AACxD,wDAAwD;AACxD;AACA;AACA,sDAAsD;AACtD,sDAAsD;AACtD;AACA,sDAAsD;AACtD,sDAAsD;AACtD,qEAAqE;AACrE,2DAA2D;AAC3D,mDAAmD;AACnD,2CAA2C;AAC3C,6DAA6D;AAC7D,0DAA0D;AAC1D,6DAA6D;AAC7D,2CAA2C;AAC3C,gDAAgD;AAChD,gDAAgD;AAChD,uCAAuC;AACvC;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,oDAAoD;;AAEpD,6CAA6C;;AAE7C;AACA;AACA;AACA,kCAAkC;AAClC;AACA;;AAEA,qCAAqC;AACrC;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,QAAQ;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kDAAkD;;AAElD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,KAAK;AACrB;AACA;AACA,oCAAoC,gBAAgB;AACpD;AACA;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,gBAAgB,KAAK;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA,SAAS;AACT;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA,gBAAgB,KAAK;AACrB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,KAAK;AACrB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,gBAAgB,KAAK;AACrB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,QAAQ;AACzB;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,wCAAwC,QAAQ;AAChD;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,mCAAmC;AAC3E;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,gBAAgB,OAAO;AACvB,gBAAgB,OAAO;AACvB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,2CAA2C;AAC3C,gEAAgE,gEAAgE;AAChI;;AAEA;AACA,OAAO,wCAAwC,wFAAwF,oKAAoK,uHAAuH,mBAAmB;AACrb;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,KAAK;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;;AAEA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,iBAAiB;AACjC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,gBAAgB,OAAO;AACvB,gBAAgB,OAAO;AACvB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA,uBAAuB;AACvB;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,SAAS;AACxB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,CAAC;AACD;;;;;;;;;;;;;;;;;;ACj0CiC;AACA;AAC1B;AACP,6BAA6B,cAAc;AAC3C,WAAW,+CAAM,QAAQ,+CAAQ,EAAE,iBAAiB;AACpD;AACA,iC;;;;;;;;;;;ACNa;;AAEb;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,gBAAgB;AAC3B,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,gBAAgB;AAC3B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yDAAyD,OAAO;AAChE;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,yCAAyC,SAAS;AAClD;AACA;;AAEA;AACA,GAAG;AACH;AACA;;AAEA,eAAe,YAAY;AAC3B;;AAEA;AACA,2DAA2D;AAC3D,+DAA+D;AAC/D,mEAAmE;AACnE,uEAAuE;AACvE;AACA,0DAA0D,SAAS;AACnE;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,aAAa,aAAa;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,aAAa,aAAa;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB,aAAa,aAAa;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,2DAA2D,YAAY;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,aAAa,aAAa;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI,IAA6B;AACjC;AACA;;;;;;;;;;;AC/UA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACO;AACP;AACA;AACA,gEAAgE,oBAAoB,EAAE;AACtF;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,iC;;;;;;;;;;AC/CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,cAAc;AACzB,WAAW,OAAO;AAClB,YAAY,MAAM;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACjKuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,6BAA6B,cAAc;AAC3C,kOAAkO,iDAAS;AAC3O;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,iCAAiC,EAAE;AAC9E;AACA,iC;;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;;AAGb,gBAAgB,OAAO;AACvB,WAAW,mBAAO,CAAC,yCAAM;;;AAGzB;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB;AACnC;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,QAAQ,oBAAoB;AAC5B;AACA;AACA;;AAEA;AACA,QAAQ,UAAU;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAwB,EAAE;;AAE1B;AACA;AACA,uBAAuB,IAAI;;AAE3B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,oCAAoC,SAAS;AAC7C;AACA;AACA;AACA,KAAK;AACL,aAAa,OAAO;AACpB,KAAK;AACL;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA,gBAAgB,EAAE;AAClB,qCAAqC,GAAG;AACxC;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,+BAA+B,2BAA2B;AAC1D;AACA;;AAEA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA,oBAAoB;;;AAGpB;AACA;AACA;AACA,6BAA6B,IAAI;AACjC;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;;AAEA,oCAAoC,8BAA8B;AAClE,yCAAyC,OAAO;;AAEhD;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA,+BAA+B,sBAAsB;AACrD;AACA;;AAEA;;AAEA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA,oBAAoB;AACpB,oBAAoB;;;;;;;;;;;;;;;;ACnnBpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;;AAEA;AACA;AACA;AACA,UAAU;AACV;;AAEA;AACA;AACA;AACA,YAAY,OAAO;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY,OAAO;AACnB;;AAEA;AACA;;AAEA;AACA,EAAE;;AAEF;AACA;AACA,YAAY,OAAO;AACnB,YAAY,OAAO;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,OAAO;AACrB,cAAc,eAAe;AAC7B,cAAc;AACd;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,OAAO;AACnB,YAAY,OAAO;AACnB,YAAY,OAAO;AACnB;AACA,YAAY;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,QAAQ,IAAqC;AAC7C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,0BAA0B,YAAY,aAAa;AACnD;AACA;;AAEA;AACA,YAAY,IAAqC;AACjD;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,QAAQ,IAAqC;AAC7C;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,QAAQ;;;AAGR,iEAAiE;;;AAGjE;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA,QAAQ,IAAqC;AAC7C;AACA;;AAEA;AACA;AACA;;AAEA;AACA,CAAC;AACD;AACA;AACA,WAAW,OAAO;AAClB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,QAAQ,IAAqC;AAC7C;AACA;AACA;;AAEA;AACA;;AAEA,UAAU,IAAqC;AAC/C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,OAAO;;;AAGP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP,KAAK;AACL;;AAEA;;AAEA;AACA,QAAQ,IAAqC;AAC7C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA,CAAC;AACD;AACA;AACA,UAAU;AACV;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,aAAa,OAAO;AACpB,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,OAAO;AACrB,cAAc,QAAQ;AACtB;;;AAGA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,cAAc,IAAqC;AACnD;AACA;;AAEA;;AAEA;;AAEA,cAAc,IAAqC;AACnD;AACA;;AAEA;AACA,SAAS;AACT;;;AAGA,YAAY,IAAqC;AACjD;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA,YAAY,IAAqC;AACjD;AACA;AACA,WAAW;AACX;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;;AAEA,UAAU,IAAqC;AAC/C;AACA;AACA,SAAS;AACT;;AAEA;AACA,KAAK;AACL;;AAEA;AACA,CAAC;AACD;AACA;AACA,UAAU;AACV;;;AAGA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,QAAQ;AACtB;;;AAGA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,cAAc,IAAqC;AACnD;AACA;;AAEA;;AAEA,cAAc,IAAqC;AACnD;AACA;;AAEA;AACA;AACA;AACA,WAAW;AACX,yCAAyC;;AAEzC;;AAEA;AACA;AACA;AACA,aAAa;;AAEb,gBAAgB,IAAqC;AACrD;AACA;AACA;;AAEA,cAAc,IAAqC;AACnD;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,KAAK;AACL;;AAEA;AACA,CAAC;;AAED,iEAAe,QAAQ,EAAC;;;;;;;;;;;ACxexB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;;;;;;;ACvLL;AACE;AAC5B;AACP,6BAA6B,cAAc;AAC3C,WAAW,iDAAO,QAAQ,+CAAQ,EAAE,iBAAiB;AACrD;AACA,iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNgC;AACS;AACf;AACW;AACmB;AACxD,cAAc,4CAAK;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,OAAO,EAAE,GAAG;AACxC,kCAAkC,WAAW,EAAE,GAAG;AACzD;AACA;AACA;AACA,6BAA6B,sDAAY;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAQ;AACtC;AACA;AACA;AACA,aAAa;AACb;AACA,8BAA8B,kDAAQ;AACtC,2DAA2D,QAAQ;AACnE;AACA,aAAa;AACb,uCAAuC,gBAAgB;AACvD;AACA,aAAa;AACb,8BAA8B,oBAAoB;AAClD,yBAAyB,eAAe;AACxC;AACA,mCAAmC,GAAG,GAAG,KAAK;AAC9C;AACA;AACA;AACA,aAAa;AACb,6BAA6B,gBAAgB;AAC7C,qCAAqC,MAAM;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,8BAA8B,mDAAc;AAC5C;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;AACA,gDAAgD,IAAI;AACpD;AACA;AACA,6DAA6D,gBAAgB;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,KAAK;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA,sCAAsC;AACtC,sBAAsB,kDAAQ;AAC9B;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,8BAA8B,6CAAQ;AACtC;AACA;AACA;AACA,oBAAoB;AACpB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,YAAY;AACzB;AACA;AACA;AACA;AACA;AACA,+CAA+C,gBAAgB;AAC/D;AACA,+DAA+D;AAC/D,iBAAiB;AACjB;AACA;AACA,0DAA0D,sCAAsC,EAAE;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA,0CAA0C,iEAAmB;AAC7D;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAC0B;;;;;;;;;;;;;;;;;;;ACtPe;AACM;AAC/C;AACA,OAAO,qCAAqC;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,kCAAkC,sDAAY;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,eAAe,cAAc;AAC7B;AACA;AACA,eAAe,wBAAwB,4BAA4B,mBAAmB;AACtF;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,kDAAkD,wDAAY;AAC9D,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,eAAe;AACxD,uCAAuC,QAAQ;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAC+B;;;;;;;;;;;;;;;;;;;;;;;;AChFO;AACa;AACzB;AACa;AACE;AACzC,cAAc,4CAAK;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,IAAI,EAAE,mBAAmB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,IAAI,EAAE,mBAAmB;AACtE;AACA;AACA;AACA,uCAAuC,mBAAmB;AAC1D,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,2BAA2B,sDAAY;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA,2CAA2C,OAAO;AAClD,SAAS;AACT;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,iBAAiB;AAClD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mDAAS;AAChC;AACA;AACA,4CAA4C,YAAY,IAAI,cAAc;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,IAAI,GAAG,qDAAS,IAAI;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,mCAAmC;AACnC,uBAAuB,4DAAc;AACrC,8CAA8C;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClPuC;AAChC;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,IAAI;AAClF;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,oBAAoB,qDAAS;AAC7B;AACA;AACA;AACA;AACA;AACA,+CAA+C,OAAO;AACtD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACO;AACP;AACA,mEAAmE,IAAI;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,uBAAuB,QAAQ;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,cAAc,mCAAmC,SAAS;AACnF;AACA;AACA,mBAAmB,OAAO,GAAG,MAAM;AACnC,6DAA6D,IAAI;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,KAAK;AAC5D;AACA;AACA,iDAAiD,cAAc;AAC/D;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClNA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAU,gBAAgB,sCAAsC,iBAAiB,EAAE;AACnF,yBAAyB,8EAA8E;AACvG;AACA;;AAEO;AACP;AACA;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;;AAEO;AACP;AACA,gDAAgD,OAAO;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO;AACP;AACA;AACA;AACA;AACA,4DAA4D,cAAc;AAC1E;AACA;AACA;AACA;AACA;;AAEO;AACP;AACA;AACA,4CAA4C,QAAQ;AACpD;AACA;;AAEO;AACP,mCAAmC,oCAAoC;AACvE;;AAEO;AACP;AACA;;AAEO;AACP,2BAA2B,+DAA+D,gBAAgB,EAAE,EAAE;AAC9G;AACA,mCAAmC,MAAM,6BAA6B,EAAE,YAAY,WAAW,EAAE;AACjG,kCAAkC,MAAM,iCAAiC,EAAE,YAAY,WAAW,EAAE;AACpG,+BAA+B,qFAAqF;AACpH;AACA,KAAK;AACL;;AAEO;AACP,aAAa,6BAA6B,0BAA0B,aAAa,EAAE,qBAAqB;AACxG,gBAAgB,qDAAqD,oEAAoE,aAAa,EAAE;AACxJ,sBAAsB,sBAAsB,qBAAqB,GAAG;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC,kCAAkC,SAAS;AAC3C,kCAAkC,WAAW,UAAU;AACvD,yCAAyC,cAAc;AACvD;AACA,6GAA6G,OAAO,UAAU;AAC9H,gFAAgF,iBAAiB,OAAO;AACxG,wDAAwD,gBAAgB,QAAQ,OAAO;AACvF,8CAA8C,gBAAgB,gBAAgB,OAAO;AACrF;AACA,iCAAiC;AACjC;AACA;AACA,SAAS,YAAY,aAAa,OAAO,EAAE,UAAU,WAAW;AAChE,mCAAmC,SAAS;AAC5C;AACA;;AAEO;AACP;AACA,kCAAkC,oCAAoC,aAAa,EAAE,EAAE;AACvF,CAAC;AACD;AACA;AACA,CAAC;;AAEM;AACP;AACA;;AAEO;AACP;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;;AAEO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;;AAEA;AACO;AACP,4BAA4B,sBAAsB;AAClD;AACA;AACA;;AAEA;AACO;AACP,iDAAiD,QAAQ;AACzD,wCAAwC,QAAQ;AAChD,wDAAwD,QAAQ;AAChE;AACA;AACA;;AAEO;AACP,oDAAoD,QAAQ;AAC5D;AACA;AACA;;AAEO;AACP;AACA;;AAEO;AACP;AACA;AACA,iBAAiB,sFAAsF,aAAa,EAAE;AACtH,sBAAsB,gCAAgC,qCAAqC,0CAA0C,EAAE,EAAE,GAAG;AAC5I,2BAA2B,MAAM,eAAe,EAAE,YAAY,oBAAoB,EAAE;AACpF,sBAAsB,oGAAoG;AAC1H,6BAA6B,uBAAuB;AACpD,4BAA4B,wBAAwB;AACpD,2BAA2B,yDAAyD;AACpF;;AAEO;AACP;AACA,iBAAiB,4CAA4C,SAAS,EAAE,qDAAqD,aAAa,EAAE;AAC5I,yBAAyB,6BAA6B,oBAAoB,gDAAgD,gBAAgB,EAAE,KAAK;AACjJ;;AAEO;AACP;AACA;AACA,2GAA2G,sFAAsF,aAAa,EAAE;AAChN,sBAAsB,8BAA8B,gDAAgD,uDAAuD,EAAE,EAAE,GAAG;AAClK,4CAA4C,sCAAsC,UAAU,oBAAoB,EAAE,EAAE,UAAU;AAC9H;;AAEO;AACP,gCAAgC,uCAAuC,aAAa,EAAE,EAAE,OAAO,kBAAkB;AACjH;AACA;;AAEA;AACA,yCAAyC,6BAA6B;AACtE,CAAC;AACD;AACA;;AAEO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEO;AACP,4CAA4C;AAC5C;;AAEO;AACP;AACA;AACA;AACA;AACA;;AAEO;AACP;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AC5OA;AACA;AACA;AACA;AACA;AACA,C;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,uBAAuB,SAAS;AAChC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,kBAAkB,qBAAM;AACxB;AACA;AACA;AACA;;AAEA,MAAM,OAAO;AACb;AACA;;AAEA;AACA;AACA;AACA,UAAU,OAAO;AACjB;AACA,OAAO,UAAU,OAAO;AACxB;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA,gBAAgB;AAChB;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;;;AAGf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA,GAAG;;AAEH;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4CAA4C,KAAK;;AAEjD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;;AAEA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA,mCAAmC,OAAO;AAC1C;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;;AAGA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA,eAAe;;AAEf;AACA;AACA;AACA,iBAAiB;;AAEjB;AACA;AACA;AACA,cAAc;;AAEd;AACA;AACA;AACA,yBAAyB;;AAEzB;AACA;AACA;AACA,gBAAgB;;AAEhB;AACA;AACA;AACA,gBAAgB;;AAEhB;AACA;AACA;AACA,gBAAgB;;AAEhB;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA;AACA;AACA,gBAAgB;;AAEhB;AACA;AACA;AACA,gBAAgB;;AAEhB;AACA;AACA;AACA,cAAc;;AAEd;AACA;AACA;AACA;AACA,eAAe;;AAEf;AACA;AACA;AACA,kBAAkB;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB,kHAAgD;;AAEhD;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA,WAAW;AACX;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA,WAAW,SAAS;AACpB;AACA,qGAAsC;;AAEtC,eAAe;AACf;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;UCzkBA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCrBA;WACA;WACA;WACA;WACA;WACA,gCAAgC,YAAY;WAC5C;WACA,E;;;;;WCPA;WACA;WACA;WACA;WACA,wCAAwC,yCAAyC;WACjF;WACA;WACA,E;;;;;WCPA;WACA;WACA;WACA;WACA,EAAE;WACF;WACA;WACA,CAAC,I;;;;;WCPD,wF;;;;;WCAA;WACA;WACA;WACA,sDAAsD,kBAAkB;WACxE;WACA,+CAA+C,cAAc;WAC7D,E;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNyC;AAC0H;AACzI;AACqI;AACxH;AACL;AACL;AAC7B,cAAc,4CAAK;AACnB;AACA;AACA;AACA,6BAA6B,sDAAY;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,mDAAS,GAAG;AAC9B;AACA;AACA;AACA;AACA;AACA,iBAAiB,kDAAQ;AACzB,YAAY,mDAAS;AACrB;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA,2BAA2B,sDAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,WAAW,GAAG,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,UAAU,IAAI,gCAAgC;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,sDAAsD;AACvD;AACA,qCAAqC,MAAM;AAC3C;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,oCAAoC,MAAM;AAC1C,mCAAmC,0BAA0B;AAC7D;AACA;AACA,sDAAsD,uCAAuC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,+DAAqB;AACjC;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA,mCAAmC,MAAM;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,4DAAkB;AAC/C,4CAA4C,IAAI,GAAG,eAAe;AAClE;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA,0BAA0B,yDAAkB;AAC5C,iCAAiC,0DAAoB;AACrD;AACA,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA,8BAA8B,MAAM;AACpC;AACA;AACA;AACA,wBAAwB,+DAAqB;AAC7C;AACA;AACA;AACA,iBAAiB,8DAAgB;AACjC;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,yDAAW;AAC7D;AACA,iBAAiB;AACjB;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,sDAAY;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,+CAAK;AACxC;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA,+DAA+D,+DAAqB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,+DAAqB;AACzC;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAM;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,+DAAqB;AAC7C;AACA,+DAA+D,IAAI;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sCAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,+DAAqB,6BAA6B,iBAAiB;AACzF;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,mCAAmC;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,kBAAkB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,+DAAqB;AACjD,8BAA8B,+DAAqB,2BAA2B,SAAS;AACvF;AACA;AACA;AACA;AACA,mBAAmB,QAAQ;AAC3B;AACA;AACA;AACA,iBAAiB,MAAM;AACvB;AACA;AACA,8BAA8B,0DAAgB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,sCAAS;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,4DAAc;AAC7C;AACA;AACA,4CAA4C,0DAAY;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA,kDAAkD,gEAAc,CAAC,kEAAoB;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,SAAS,GAAG,WAAW;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,sDAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,kDAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,+DAAqB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,+DAAqB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,kDAAQ;AAClE;AACA;AACA;AACA;AACA;AACA,iBAAiB,eAAe,MAAM;AACtC;AACA;AACA,uBAAuB,MAAM;AAC7B;AACA,mDAAmD,qBAAqB;AACxE;AACA;AACA,uBAAuB,UAAU;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,6DAAe,GAAG,aAAa;AACrF,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,mCAAmC;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,oDAAM;AAC9C,8BAA8B,qDAAS;AACvC,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,OAAO;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA,QAAQ,4DAAkB;AAC1B;AACA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,KAAK;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACwC","file":"lsplugin.core.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"LSPlugin\"] = factory();\n\telse\n\t\troot[\"LSPlugin\"] = factory();\n})(self, function() {\nreturn ","/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","/*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, global.DOMPurify = factory());\n}(this, function () { 'use strict';\n\n  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n  var hasOwnProperty = Object.hasOwnProperty,\n      setPrototypeOf = Object.setPrototypeOf,\n      isFrozen = Object.isFrozen,\n      getPrototypeOf = Object.getPrototypeOf,\n      getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n  var freeze = Object.freeze,\n      seal = Object.seal,\n      create = Object.create; // eslint-disable-line import/no-mutable-exports\n\n  var _ref = typeof Reflect !== 'undefined' && Reflect,\n      apply = _ref.apply,\n      construct = _ref.construct;\n\n  if (!apply) {\n    apply = function apply(fun, thisValue, args) {\n      return fun.apply(thisValue, args);\n    };\n  }\n\n  if (!freeze) {\n    freeze = function freeze(x) {\n      return x;\n    };\n  }\n\n  if (!seal) {\n    seal = function seal(x) {\n      return x;\n    };\n  }\n\n  if (!construct) {\n    construct = function construct(Func, args) {\n      return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))();\n    };\n  }\n\n  var arrayForEach = unapply(Array.prototype.forEach);\n  var arrayPop = unapply(Array.prototype.pop);\n  var arrayPush = unapply(Array.prototype.push);\n\n  var stringToLowerCase = unapply(String.prototype.toLowerCase);\n  var stringMatch = unapply(String.prototype.match);\n  var stringReplace = unapply(String.prototype.replace);\n  var stringIndexOf = unapply(String.prototype.indexOf);\n  var stringTrim = unapply(String.prototype.trim);\n\n  var regExpTest = unapply(RegExp.prototype.test);\n\n  var typeErrorCreate = unconstruct(TypeError);\n\n  function unapply(func) {\n    return function (thisArg) {\n      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n\n      return apply(func, thisArg, args);\n    };\n  }\n\n  function unconstruct(func) {\n    return function () {\n      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      return construct(func, args);\n    };\n  }\n\n  /* Add properties to a lookup table */\n  function addToSet(set, array) {\n    if (setPrototypeOf) {\n      // Make 'in' and truthy checks like Boolean(set.constructor)\n      // independent of any properties defined on Object.prototype.\n      // Prevent prototype setters from intercepting set as a this value.\n      setPrototypeOf(set, null);\n    }\n\n    var l = array.length;\n    while (l--) {\n      var element = array[l];\n      if (typeof element === 'string') {\n        var lcElement = stringToLowerCase(element);\n        if (lcElement !== element) {\n          // Config presets (e.g. tags.js, attrs.js) are immutable.\n          if (!isFrozen(array)) {\n            array[l] = lcElement;\n          }\n\n          element = lcElement;\n        }\n      }\n\n      set[element] = true;\n    }\n\n    return set;\n  }\n\n  /* Shallow clone an object */\n  function clone(object) {\n    var newObject = create(null);\n\n    var property = void 0;\n    for (property in object) {\n      if (apply(hasOwnProperty, object, [property])) {\n        newObject[property] = object[property];\n      }\n    }\n\n    return newObject;\n  }\n\n  /* IE10 doesn't support __lookupGetter__ so lets'\n   * simulate it. It also automatically checks\n   * if the prop is function or getter and behaves\n   * accordingly. */\n  function lookupGetter(object, prop) {\n    while (object !== null) {\n      var desc = getOwnPropertyDescriptor(object, prop);\n      if (desc) {\n        if (desc.get) {\n          return unapply(desc.get);\n        }\n\n        if (typeof desc.value === 'function') {\n          return unapply(desc.value);\n        }\n      }\n\n      object = getPrototypeOf(object);\n    }\n\n    function fallbackValue(element) {\n      console.warn('fallback value for', element);\n      return null;\n    }\n\n    return fallbackValue;\n  }\n\n  var html = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);\n\n  // SVG\n  var svg = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);\n\n  var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);\n\n  // List of SVG elements that are disallowed by default.\n  // We still need to know them so that we can do namespace\n  // checks properly in case one wants to add them to\n  // allow-list.\n  var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);\n\n  var mathMl = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']);\n\n  // Similarly to SVG, we want to know all MathML elements,\n  // even those that we disallow by default.\n  var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);\n\n  var text = freeze(['#text']);\n\n  var html$1 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns']);\n\n  var svg$1 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);\n\n  var mathMl$1 = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);\n\n  var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);\n\n  // eslint-disable-next-line unicorn/better-regex\n  var MUSTACHE_EXPR = seal(/\\{\\{[\\s\\S]*|[\\s\\S]*\\}\\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode\n  var ERB_EXPR = seal(/<%[\\s\\S]*|[\\s\\S]*%>/gm);\n  var DATA_ATTR = seal(/^data-[\\-\\w.\\u00B7-\\uFFFF]/); // eslint-disable-line no-useless-escape\n  var ARIA_ATTR = seal(/^aria-[\\-\\w]+$/); // eslint-disable-line no-useless-escape\n  var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i // eslint-disable-line no-useless-escape\n  );\n  var IS_SCRIPT_OR_DATA = seal(/^(?:\\w+script|data):/i);\n  var ATTR_WHITESPACE = seal(/[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205F\\u3000]/g // eslint-disable-line no-control-regex\n  );\n\n  var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n  function _toConsumableArray$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n  var getGlobal = function getGlobal() {\n    return typeof window === 'undefined' ? null : window;\n  };\n\n  /**\n   * Creates a no-op policy for internal use only.\n   * Don't export this function outside this module!\n   * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.\n   * @param {Document} document The document object (to determine policy name suffix)\n   * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types\n   * are not supported).\n   */\n  var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {\n    if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {\n      return null;\n    }\n\n    // Allow the callers to control the unique policy name\n    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.\n    // Policy creation with duplicate names throws in Trusted Types.\n    var suffix = null;\n    var ATTR_NAME = 'data-tt-policy-suffix';\n    if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {\n      suffix = document.currentScript.getAttribute(ATTR_NAME);\n    }\n\n    var policyName = 'dompurify' + (suffix ? '#' + suffix : '');\n\n    try {\n      return trustedTypes.createPolicy(policyName, {\n        createHTML: function createHTML(html$$1) {\n          return html$$1;\n        }\n      });\n    } catch (_) {\n      // Policy creation failed (most likely another DOMPurify script has\n      // already run). Skip creating the policy, as this will only cause errors\n      // if TT are enforced.\n      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');\n      return null;\n    }\n  };\n\n  function createDOMPurify() {\n    var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();\n\n    var DOMPurify = function DOMPurify(root) {\n      return createDOMPurify(root);\n    };\n\n    /**\n     * Version label, exposed for easier checks\n     * if DOMPurify is up to date or not\n     */\n    DOMPurify.version = '2.2.7';\n\n    /**\n     * Array of elements that DOMPurify removed during sanitation.\n     * Empty if nothing was removed.\n     */\n    DOMPurify.removed = [];\n\n    if (!window || !window.document || window.document.nodeType !== 9) {\n      // Not running in a browser, provide a factory function\n      // so that you can pass your own Window\n      DOMPurify.isSupported = false;\n\n      return DOMPurify;\n    }\n\n    var originalDocument = window.document;\n\n    var document = window.document;\n    var DocumentFragment = window.DocumentFragment,\n        HTMLTemplateElement = window.HTMLTemplateElement,\n        Node = window.Node,\n        Element = window.Element,\n        NodeFilter = window.NodeFilter,\n        _window$NamedNodeMap = window.NamedNodeMap,\n        NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,\n        Text = window.Text,\n        Comment = window.Comment,\n        DOMParser = window.DOMParser,\n        trustedTypes = window.trustedTypes;\n\n\n    var ElementPrototype = Element.prototype;\n\n    var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');\n    var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');\n    var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');\n    var getParentNode = lookupGetter(ElementPrototype, 'parentNode');\n\n    // As per issue #47, the web-components registry is inherited by a\n    // new document created via createHTMLDocument. As per the spec\n    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)\n    // a new empty registry is used when creating a template contents owner\n    // document, so we use that as our parent document to ensure nothing\n    // is inherited.\n    if (typeof HTMLTemplateElement === 'function') {\n      var template = document.createElement('template');\n      if (template.content && template.content.ownerDocument) {\n        document = template.content.ownerDocument;\n      }\n    }\n\n    var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);\n    var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : '';\n\n    var _document = document,\n        implementation = _document.implementation,\n        createNodeIterator = _document.createNodeIterator,\n        getElementsByTagName = _document.getElementsByTagName,\n        createDocumentFragment = _document.createDocumentFragment;\n    var importNode = originalDocument.importNode;\n\n\n    var documentMode = {};\n    try {\n      documentMode = clone(document).documentMode ? document.documentMode : {};\n    } catch (_) {}\n\n    var hooks = {};\n\n    /**\n     * Expose whether this browser supports running the full DOMPurify.\n     */\n    DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;\n\n    var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR,\n        ERB_EXPR$$1 = ERB_EXPR,\n        DATA_ATTR$$1 = DATA_ATTR,\n        ARIA_ATTR$$1 = ARIA_ATTR,\n        IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA,\n        ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;\n    var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;\n\n    /**\n     * We consider the elements and attributes below to be safe. Ideally\n     * don't add any new ones but feel free to remove unwanted ones.\n     */\n\n    /* allowed element names */\n\n    var ALLOWED_TAGS = null;\n    var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));\n\n    /* Allowed attribute names */\n    var ALLOWED_ATTR = null;\n    var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));\n\n    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */\n    var FORBID_TAGS = null;\n\n    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */\n    var FORBID_ATTR = null;\n\n    /* Decide if ARIA attributes are okay */\n    var ALLOW_ARIA_ATTR = true;\n\n    /* Decide if custom data attributes are okay */\n    var ALLOW_DATA_ATTR = true;\n\n    /* Decide if unknown protocols are okay */\n    var ALLOW_UNKNOWN_PROTOCOLS = false;\n\n    /* Output should be safe for common template engines.\n     * This means, DOMPurify removes data attributes, mustaches and ERB\n     */\n    var SAFE_FOR_TEMPLATES = false;\n\n    /* Decide if document with <html>... should be returned */\n    var WHOLE_DOCUMENT = false;\n\n    /* Track whether config is already set on this instance of DOMPurify. */\n    var SET_CONFIG = false;\n\n    /* Decide if all elements (e.g. style, script) must be children of\n     * document.body. By default, browsers might move them to document.head */\n    var FORCE_BODY = false;\n\n    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html\n     * string (or a TrustedHTML object if Trusted Types are supported).\n     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead\n     */\n    var RETURN_DOM = false;\n\n    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html\n     * string  (or a TrustedHTML object if Trusted Types are supported) */\n    var RETURN_DOM_FRAGMENT = false;\n\n    /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM\n     * `Node` is imported into the current `Document`. If this flag is not enabled the\n     * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by\n     * DOMPurify.\n     *\n     * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`\n     * might cause XSS from attacks hidden in closed shadowroots in case the browser\n     * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/\n     */\n    var RETURN_DOM_IMPORT = true;\n\n    /* Try to return a Trusted Type object instead of a string, return a string in\n     * case Trusted Types are not supported  */\n    var RETURN_TRUSTED_TYPE = false;\n\n    /* Output should be free from DOM clobbering attacks? */\n    var SANITIZE_DOM = true;\n\n    /* Keep element content when removing element? */\n    var KEEP_CONTENT = true;\n\n    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead\n     * of importing it into a new Document and returning a sanitized copy */\n    var IN_PLACE = false;\n\n    /* Allow usage of profiles like html, svg and mathMl */\n    var USE_PROFILES = {};\n\n    /* Tags to ignore content of when KEEP_CONTENT is true */\n    var FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);\n\n    /* Tags that are safe for data: URIs */\n    var DATA_URI_TAGS = null;\n    var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);\n\n    /* Attributes safe for values like \"javascript:\" */\n    var URI_SAFE_ATTRIBUTES = null;\n    var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'summary', 'title', 'value', 'style', 'xmlns']);\n\n    /* Keep a reference to config to pass to hooks */\n    var CONFIG = null;\n\n    /* Ideally, do not touch anything below this line */\n    /* ______________________________________________ */\n\n    var formElement = document.createElement('form');\n\n    /**\n     * _parseConfig\n     *\n     * @param  {Object} cfg optional config literal\n     */\n    // eslint-disable-next-line complexity\n    var _parseConfig = function _parseConfig(cfg) {\n      if (CONFIG && CONFIG === cfg) {\n        return;\n      }\n\n      /* Shield configuration object from tampering */\n      if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof(cfg)) !== 'object') {\n        cfg = {};\n      }\n\n      /* Shield configuration object from prototype pollution */\n      cfg = clone(cfg);\n\n      /* Set configuration parameters */\n      ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;\n      ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;\n      URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;\n      DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;\n      FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};\n      FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};\n      USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;\n      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true\n      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true\n      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false\n      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false\n      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false\n      RETURN_DOM = cfg.RETURN_DOM || false; // Default false\n      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false\n      RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true\n      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false\n      FORCE_BODY = cfg.FORCE_BODY || false; // Default false\n      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true\n      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true\n      IN_PLACE = cfg.IN_PLACE || false; // Default false\n      IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;\n      if (SAFE_FOR_TEMPLATES) {\n        ALLOW_DATA_ATTR = false;\n      }\n\n      if (RETURN_DOM_FRAGMENT) {\n        RETURN_DOM = true;\n      }\n\n      /* Parse profile info */\n      if (USE_PROFILES) {\n        ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));\n        ALLOWED_ATTR = [];\n        if (USE_PROFILES.html === true) {\n          addToSet(ALLOWED_TAGS, html);\n          addToSet(ALLOWED_ATTR, html$1);\n        }\n\n        if (USE_PROFILES.svg === true) {\n          addToSet(ALLOWED_TAGS, svg);\n          addToSet(ALLOWED_ATTR, svg$1);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n\n        if (USE_PROFILES.svgFilters === true) {\n          addToSet(ALLOWED_TAGS, svgFilters);\n          addToSet(ALLOWED_ATTR, svg$1);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n\n        if (USE_PROFILES.mathMl === true) {\n          addToSet(ALLOWED_TAGS, mathMl);\n          addToSet(ALLOWED_ATTR, mathMl$1);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n      }\n\n      /* Merge configuration parameters */\n      if (cfg.ADD_TAGS) {\n        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {\n          ALLOWED_TAGS = clone(ALLOWED_TAGS);\n        }\n\n        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);\n      }\n\n      if (cfg.ADD_ATTR) {\n        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {\n          ALLOWED_ATTR = clone(ALLOWED_ATTR);\n        }\n\n        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);\n      }\n\n      if (cfg.ADD_URI_SAFE_ATTR) {\n        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);\n      }\n\n      /* Add #text in case KEEP_CONTENT is set to true */\n      if (KEEP_CONTENT) {\n        ALLOWED_TAGS['#text'] = true;\n      }\n\n      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */\n      if (WHOLE_DOCUMENT) {\n        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);\n      }\n\n      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */\n      if (ALLOWED_TAGS.table) {\n        addToSet(ALLOWED_TAGS, ['tbody']);\n        delete FORBID_TAGS.tbody;\n      }\n\n      // Prevent further manipulation of configuration.\n      // Not available in IE8, Safari 5, etc.\n      if (freeze) {\n        freeze(cfg);\n      }\n\n      CONFIG = cfg;\n    };\n\n    var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);\n\n    var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']);\n\n    /* Keep track of all possible SVG and MathML tags\n     * so that we can perform the namespace checks\n     * correctly. */\n    var ALL_SVG_TAGS = addToSet({}, svg);\n    addToSet(ALL_SVG_TAGS, svgFilters);\n    addToSet(ALL_SVG_TAGS, svgDisallowed);\n\n    var ALL_MATHML_TAGS = addToSet({}, mathMl);\n    addToSet(ALL_MATHML_TAGS, mathMlDisallowed);\n\n    var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\n    var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n    var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';\n\n    /**\n     *\n     *\n     * @param  {Element} element a DOM element whose namespace is being checked\n     * @returns {boolean} Return false if the element has a\n     *  namespace that a spec-compliant parser would never\n     *  return. Return true otherwise.\n     */\n    var _checkValidNamespace = function _checkValidNamespace(element) {\n      var parent = getParentNode(element);\n\n      // In JSDOM, if we're inside shadow DOM, then parentNode\n      // can be null. We just simulate parent in this case.\n      if (!parent || !parent.tagName) {\n        parent = {\n          namespaceURI: HTML_NAMESPACE,\n          tagName: 'template'\n        };\n      }\n\n      var tagName = stringToLowerCase(element.tagName);\n      var parentTagName = stringToLowerCase(parent.tagName);\n\n      if (element.namespaceURI === SVG_NAMESPACE) {\n        // The only way to switch from HTML namespace to SVG\n        // is via <svg>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'svg';\n        }\n\n        // The only way to switch from MathML to SVG is via\n        // svg if parent is either <annotation-xml> or MathML\n        // text integration points.\n        if (parent.namespaceURI === MATHML_NAMESPACE) {\n          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);\n        }\n\n        // We only allow elements that are defined in SVG\n        // spec. All others are disallowed in SVG namespace.\n        return Boolean(ALL_SVG_TAGS[tagName]);\n      }\n\n      if (element.namespaceURI === MATHML_NAMESPACE) {\n        // The only way to switch from HTML namespace to MathML\n        // is via <math>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'math';\n        }\n\n        // The only way to switch from SVG to MathML is via\n        // <math> and HTML integration points\n        if (parent.namespaceURI === SVG_NAMESPACE) {\n          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];\n        }\n\n        // We only allow elements that are defined in MathML\n        // spec. All others are disallowed in MathML namespace.\n        return Boolean(ALL_MATHML_TAGS[tagName]);\n      }\n\n      if (element.namespaceURI === HTML_NAMESPACE) {\n        // The only way to switch from SVG to HTML is via\n        // HTML integration points, and from MathML to HTML\n        // is via MathML text integration points\n        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n\n        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n\n        // Certain elements are allowed in both SVG and HTML\n        // namespace. We need to specify them explicitly\n        // so that they don't get erronously deleted from\n        // HTML namespace.\n        var commonSvgAndHTMLElements = addToSet({}, ['title', 'style', 'font', 'a', 'script']);\n\n        // We disallow tags that are specific for MathML\n        // or SVG and should never appear in HTML namespace\n        return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);\n      }\n\n      // The code should never reach this place (this means\n      // that the element somehow got namespace that is not\n      // HTML, SVG or MathML). Return false just in case.\n      return false;\n    };\n\n    /**\n     * _forceRemove\n     *\n     * @param  {Node} node a DOM node\n     */\n    var _forceRemove = function _forceRemove(node) {\n      arrayPush(DOMPurify.removed, { element: node });\n      try {\n        node.parentNode.removeChild(node);\n      } catch (_) {\n        try {\n          node.outerHTML = emptyHTML;\n        } catch (_) {\n          node.remove();\n        }\n      }\n    };\n\n    /**\n     * _removeAttribute\n     *\n     * @param  {String} name an Attribute name\n     * @param  {Node} node a DOM node\n     */\n    var _removeAttribute = function _removeAttribute(name, node) {\n      try {\n        arrayPush(DOMPurify.removed, {\n          attribute: node.getAttributeNode(name),\n          from: node\n        });\n      } catch (_) {\n        arrayPush(DOMPurify.removed, {\n          attribute: null,\n          from: node\n        });\n      }\n\n      node.removeAttribute(name);\n\n      // We void attribute values for unremovable \"is\"\" attributes\n      if (name === 'is' && !ALLOWED_ATTR[name]) {\n        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {\n          try {\n            _forceRemove(node);\n          } catch (_) {}\n        } else {\n          try {\n            node.setAttribute(name, '');\n          } catch (_) {}\n        }\n      }\n    };\n\n    /**\n     * _initDocument\n     *\n     * @param  {String} dirty a string of dirty markup\n     * @return {Document} a DOM, filled with the dirty markup\n     */\n    var _initDocument = function _initDocument(dirty) {\n      /* Create a HTML document */\n      var doc = void 0;\n      var leadingWhitespace = void 0;\n\n      if (FORCE_BODY) {\n        dirty = '<remove></remove>' + dirty;\n      } else {\n        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */\n        var matches = stringMatch(dirty, /^[\\r\\n\\t ]+/);\n        leadingWhitespace = matches && matches[0];\n      }\n\n      var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;\n      /* Use the DOMParser API by default, fallback later if needs be */\n      try {\n        doc = new DOMParser().parseFromString(dirtyPayload, 'text/html');\n      } catch (_) {}\n\n      /* Use createHTMLDocument in case DOMParser is not available */\n      if (!doc || !doc.documentElement) {\n        doc = implementation.createHTMLDocument('');\n        var _doc = doc,\n            body = _doc.body;\n\n        body.parentNode.removeChild(body.parentNode.firstElementChild);\n        body.outerHTML = dirtyPayload;\n      }\n\n      if (dirty && leadingWhitespace) {\n        doc.body.insertBefore(document.createTextNode(leadingWhitespace), doc.body.childNodes[0] || null);\n      }\n\n      /* Work on whole document or just its body */\n      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];\n    };\n\n    /**\n     * _createIterator\n     *\n     * @param  {Document} root document/fragment to create iterator for\n     * @return {Iterator} iterator instance\n     */\n    var _createIterator = function _createIterator(root) {\n      return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, function () {\n        return NodeFilter.FILTER_ACCEPT;\n      }, false);\n    };\n\n    /**\n     * _isClobbered\n     *\n     * @param  {Node} elm element to check for clobbering attacks\n     * @return {Boolean} true if clobbered, false if safe\n     */\n    var _isClobbered = function _isClobbered(elm) {\n      if (elm instanceof Text || elm instanceof Comment) {\n        return false;\n      }\n\n      if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') {\n        return true;\n      }\n\n      return false;\n    };\n\n    /**\n     * _isNode\n     *\n     * @param  {Node} obj object to check whether it's a DOM node\n     * @return {Boolean} true is object is a DOM node\n     */\n    var _isNode = function _isNode(object) {\n      return (typeof Node === 'undefined' ? 'undefined' : _typeof(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';\n    };\n\n    /**\n     * _executeHook\n     * Execute user configurable hooks\n     *\n     * @param  {String} entryPoint  Name of the hook's entry point\n     * @param  {Node} currentNode node to work on with the hook\n     * @param  {Object} data additional hook parameters\n     */\n    var _executeHook = function _executeHook(entryPoint, currentNode, data) {\n      if (!hooks[entryPoint]) {\n        return;\n      }\n\n      arrayForEach(hooks[entryPoint], function (hook) {\n        hook.call(DOMPurify, currentNode, data, CONFIG);\n      });\n    };\n\n    /**\n     * _sanitizeElements\n     *\n     * @protect nodeName\n     * @protect textContent\n     * @protect removeChild\n     *\n     * @param   {Node} currentNode to check for permission to exist\n     * @return  {Boolean} true if node was killed, false if left alive\n     */\n    var _sanitizeElements = function _sanitizeElements(currentNode) {\n      var content = void 0;\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeElements', currentNode, null);\n\n      /* Check if element is clobbered or can clobber */\n      if (_isClobbered(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check if tagname contains Unicode */\n      if (stringMatch(currentNode.nodeName, /[\\u0080-\\uFFFF]/)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Now let's check the element's type and name */\n      var tagName = stringToLowerCase(currentNode.nodeName);\n\n      /* Execute a hook if present */\n      _executeHook('uponSanitizeElement', currentNode, {\n        tagName: tagName,\n        allowedTags: ALLOWED_TAGS\n      });\n\n      /* Detect mXSS attempts abusing namespace confusion */\n      if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\\w]/g, currentNode.innerHTML) && regExpTest(/<[/\\w]/g, currentNode.textContent)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove element if anything forbids its presence */\n      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n        /* Keep content except for bad-listed elements */\n        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {\n          var parentNode = getParentNode(currentNode);\n          var childNodes = getChildNodes(currentNode);\n\n          if (childNodes && parentNode) {\n            var childCount = childNodes.length;\n\n            for (var i = childCount - 1; i >= 0; --i) {\n              parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));\n            }\n          }\n        }\n\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check whether element has a valid namespace */\n      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\\/no(script|embed)/i, currentNode.innerHTML)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Sanitize element content to be template-safe */\n      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {\n        /* Get the element's text content */\n        content = currentNode.textContent;\n        content = stringReplace(content, MUSTACHE_EXPR$$1, ' ');\n        content = stringReplace(content, ERB_EXPR$$1, ' ');\n        if (currentNode.textContent !== content) {\n          arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });\n          currentNode.textContent = content;\n        }\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeElements', currentNode, null);\n\n      return false;\n    };\n\n    /**\n     * _isValidAttribute\n     *\n     * @param  {string} lcTag Lowercase tag name of containing element.\n     * @param  {string} lcName Lowercase attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid, otherwise false.\n     */\n    // eslint-disable-next-line complexity\n    var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {\n      /* Make sure attribute cannot clobber */\n      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {\n        return false;\n      }\n\n      /* Allow valid data-* attributes: At least one character after \"-\"\n          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)\n          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)\n          We don't need to check the value; it's always URI safe. */\n      if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {\n        return false;\n\n        /* Check value is safe. First, is attr inert? If so, is safe */\n      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if (!value) ; else {\n        return false;\n      }\n\n      return true;\n    };\n\n    /**\n     * _sanitizeAttributes\n     *\n     * @protect attributes\n     * @protect nodeName\n     * @protect removeAttribute\n     * @protect setAttribute\n     *\n     * @param  {Node} currentNode to sanitize\n     */\n    var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {\n      var attr = void 0;\n      var value = void 0;\n      var lcName = void 0;\n      var l = void 0;\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeAttributes', currentNode, null);\n\n      var attributes = currentNode.attributes;\n\n      /* Check if we have attributes; if not we might have a text node */\n\n      if (!attributes) {\n        return;\n      }\n\n      var hookEvent = {\n        attrName: '',\n        attrValue: '',\n        keepAttr: true,\n        allowedAttributes: ALLOWED_ATTR\n      };\n      l = attributes.length;\n\n      /* Go backwards over all attributes; safely remove bad ones */\n      while (l--) {\n        attr = attributes[l];\n        var _attr = attr,\n            name = _attr.name,\n            namespaceURI = _attr.namespaceURI;\n\n        value = stringTrim(attr.value);\n        lcName = stringToLowerCase(name);\n\n        /* Execute a hook if present */\n        hookEvent.attrName = lcName;\n        hookEvent.attrValue = value;\n        hookEvent.keepAttr = true;\n        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set\n        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);\n        value = hookEvent.attrValue;\n        /* Did the hooks approve of the attribute? */\n        if (hookEvent.forceKeepAttr) {\n          continue;\n        }\n\n        /* Remove attribute */\n        _removeAttribute(name, currentNode);\n\n        /* Did the hooks approve of the attribute? */\n        if (!hookEvent.keepAttr) {\n          continue;\n        }\n\n        /* Work around a security issue in jQuery 3.0 */\n        if (regExpTest(/\\/>/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Sanitize attribute content to be template-safe */\n        if (SAFE_FOR_TEMPLATES) {\n          value = stringReplace(value, MUSTACHE_EXPR$$1, ' ');\n          value = stringReplace(value, ERB_EXPR$$1, ' ');\n        }\n\n        /* Is `value` valid for this attribute? */\n        var lcTag = currentNode.nodeName.toLowerCase();\n        if (!_isValidAttribute(lcTag, lcName, value)) {\n          continue;\n        }\n\n        /* Handle invalid data-* attribute set by try-catching it */\n        try {\n          if (namespaceURI) {\n            currentNode.setAttributeNS(namespaceURI, name, value);\n          } else {\n            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. \"x-schema\". */\n            currentNode.setAttribute(name, value);\n          }\n\n          arrayPop(DOMPurify.removed);\n        } catch (_) {}\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeAttributes', currentNode, null);\n    };\n\n    /**\n     * _sanitizeShadowDOM\n     *\n     * @param  {DocumentFragment} fragment to iterate over recursively\n     */\n    var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {\n      var shadowNode = void 0;\n      var shadowIterator = _createIterator(fragment);\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeShadowDOM', fragment, null);\n\n      while (shadowNode = shadowIterator.nextNode()) {\n        /* Execute a hook if present */\n        _executeHook('uponSanitizeShadowNode', shadowNode, null);\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(shadowNode)) {\n          continue;\n        }\n\n        /* Deep shadow DOM detected */\n        if (shadowNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(shadowNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(shadowNode);\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeShadowDOM', fragment, null);\n    };\n\n    /**\n     * Sanitize\n     * Public method providing core sanitation functionality\n     *\n     * @param {String|Node} dirty string or DOM node\n     * @param {Object} configuration object\n     */\n    // eslint-disable-next-line complexity\n    DOMPurify.sanitize = function (dirty, cfg) {\n      var body = void 0;\n      var importedNode = void 0;\n      var currentNode = void 0;\n      var oldNode = void 0;\n      var returnNode = void 0;\n      /* Make sure we have a string to sanitize.\n        DO NOT return early, as this will return the wrong type if\n        the user has requested a DOM object rather than a string */\n      if (!dirty) {\n        dirty = '<!-->';\n      }\n\n      /* Stringify, in case dirty is an object */\n      if (typeof dirty !== 'string' && !_isNode(dirty)) {\n        // eslint-disable-next-line no-negated-condition\n        if (typeof dirty.toString !== 'function') {\n          throw typeErrorCreate('toString is not a function');\n        } else {\n          dirty = dirty.toString();\n          if (typeof dirty !== 'string') {\n            throw typeErrorCreate('dirty is not a string, aborting');\n          }\n        }\n      }\n\n      /* Check we can run. Otherwise fall back or ignore */\n      if (!DOMPurify.isSupported) {\n        if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {\n          if (typeof dirty === 'string') {\n            return window.toStaticHTML(dirty);\n          }\n\n          if (_isNode(dirty)) {\n            return window.toStaticHTML(dirty.outerHTML);\n          }\n        }\n\n        return dirty;\n      }\n\n      /* Assign config vars */\n      if (!SET_CONFIG) {\n        _parseConfig(cfg);\n      }\n\n      /* Clean up removed elements */\n      DOMPurify.removed = [];\n\n      /* Check if dirty is correctly typed for IN_PLACE */\n      if (typeof dirty === 'string') {\n        IN_PLACE = false;\n      }\n\n      if (IN_PLACE) ; else if (dirty instanceof Node) {\n        /* If dirty is a DOM element, append to an empty document to avoid\n           elements being stripped by the parser */\n        body = _initDocument('<!---->');\n        importedNode = body.ownerDocument.importNode(dirty, true);\n        if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {\n          /* Node is already a body, use as is */\n          body = importedNode;\n        } else if (importedNode.nodeName === 'HTML') {\n          body = importedNode;\n        } else {\n          // eslint-disable-next-line unicorn/prefer-node-append\n          body.appendChild(importedNode);\n        }\n      } else {\n        /* Exit directly if we have nothing to do */\n        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&\n        // eslint-disable-next-line unicorn/prefer-includes\n        dirty.indexOf('<') === -1) {\n          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;\n        }\n\n        /* Initialize the document to work on */\n        body = _initDocument(dirty);\n\n        /* Check we have a DOM node from the data */\n        if (!body) {\n          return RETURN_DOM ? null : emptyHTML;\n        }\n      }\n\n      /* Remove first element node (ours) if FORCE_BODY is set */\n      if (body && FORCE_BODY) {\n        _forceRemove(body.firstChild);\n      }\n\n      /* Get node iterator */\n      var nodeIterator = _createIterator(IN_PLACE ? dirty : body);\n\n      /* Now start iterating over the created document */\n      while (currentNode = nodeIterator.nextNode()) {\n        /* Fix IE's strange behavior with manipulated textNodes #89 */\n        if (currentNode.nodeType === 3 && currentNode === oldNode) {\n          continue;\n        }\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(currentNode)) {\n          continue;\n        }\n\n        /* Shadow DOM detected, sanitize it */\n        if (currentNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(currentNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(currentNode);\n\n        oldNode = currentNode;\n      }\n\n      oldNode = null;\n\n      /* If we sanitized `dirty` in-place, return it. */\n      if (IN_PLACE) {\n        return dirty;\n      }\n\n      /* Return sanitized string or DOM */\n      if (RETURN_DOM) {\n        if (RETURN_DOM_FRAGMENT) {\n          returnNode = createDocumentFragment.call(body.ownerDocument);\n\n          while (body.firstChild) {\n            // eslint-disable-next-line unicorn/prefer-node-append\n            returnNode.appendChild(body.firstChild);\n          }\n        } else {\n          returnNode = body;\n        }\n\n        if (RETURN_DOM_IMPORT) {\n          /*\n            AdoptNode() is not used because internal state is not reset\n            (e.g. the past names map of a HTMLFormElement), this is safe\n            in theory but we would rather not risk another attack vector.\n            The state that is cloned by importNode() is explicitly defined\n            by the specs.\n          */\n          returnNode = importNode.call(originalDocument, returnNode, true);\n        }\n\n        return returnNode;\n      }\n\n      var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;\n\n      /* Sanitize final string template-safe */\n      if (SAFE_FOR_TEMPLATES) {\n        serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' ');\n        serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' ');\n      }\n\n      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;\n    };\n\n    /**\n     * Public method to set the configuration once\n     * setConfig\n     *\n     * @param {Object} cfg configuration object\n     */\n    DOMPurify.setConfig = function (cfg) {\n      _parseConfig(cfg);\n      SET_CONFIG = true;\n    };\n\n    /**\n     * Public method to remove the configuration\n     * clearConfig\n     *\n     */\n    DOMPurify.clearConfig = function () {\n      CONFIG = null;\n      SET_CONFIG = false;\n    };\n\n    /**\n     * Public method to check if an attribute value is valid.\n     * Uses last set config, if any. Otherwise, uses config defaults.\n     * isValidAttribute\n     *\n     * @param  {string} tag Tag name of containing element.\n     * @param  {string} attr Attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.\n     */\n    DOMPurify.isValidAttribute = function (tag, attr, value) {\n      /* Initialize shared config vars if necessary. */\n      if (!CONFIG) {\n        _parseConfig({});\n      }\n\n      var lcTag = stringToLowerCase(tag);\n      var lcName = stringToLowerCase(attr);\n      return _isValidAttribute(lcTag, lcName, value);\n    };\n\n    /**\n     * AddHook\n     * Public method to add DOMPurify hooks\n     *\n     * @param {String} entryPoint entry point for the hook to add\n     * @param {Function} hookFunction function to execute\n     */\n    DOMPurify.addHook = function (entryPoint, hookFunction) {\n      if (typeof hookFunction !== 'function') {\n        return;\n      }\n\n      hooks[entryPoint] = hooks[entryPoint] || [];\n      arrayPush(hooks[entryPoint], hookFunction);\n    };\n\n    /**\n     * RemoveHook\n     * Public method to remove a DOMPurify hook at a given entryPoint\n     * (pops it from the stack of hooks if more are present)\n     *\n     * @param {String} entryPoint entry point for the hook to remove\n     */\n    DOMPurify.removeHook = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        arrayPop(hooks[entryPoint]);\n      }\n    };\n\n    /**\n     * RemoveHooks\n     * Public method to remove all DOMPurify hooks at a given entryPoint\n     *\n     * @param  {String} entryPoint entry point for the hooks to remove\n     */\n    DOMPurify.removeHooks = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        hooks[entryPoint] = [];\n      }\n    };\n\n    /**\n     * RemoveAllHooks\n     * Public method to remove all DOMPurify hooks\n     *\n     */\n    DOMPurify.removeAllHooks = function () {\n      hooks = {};\n    };\n\n    return DOMPurify;\n  }\n\n  var purify = createDOMPurify();\n\n  return purify;\n\n}));\n//# sourceMappingURL=purify.js.map\n","import { __assign } from \"tslib\";\nimport { noCase } from \"no-case\";\nexport function dotCase(input, options) {\n    if (options === void 0) { options = {}; }\n    return noCase(input, __assign({ delimiter: \".\" }, options));\n}\n//# sourceMappingURL=index.js.map","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","/**\n * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt\n */\nvar SUPPORTED_LOCALE = {\n    tr: {\n        regexp: /\\u0130|\\u0049|\\u0049\\u0307/g,\n        map: {\n            İ: \"\\u0069\",\n            I: \"\\u0131\",\n            İ: \"\\u0069\",\n        },\n    },\n    az: {\n        regexp: /\\u0130/g,\n        map: {\n            İ: \"\\u0069\",\n            I: \"\\u0131\",\n            İ: \"\\u0069\",\n        },\n    },\n    lt: {\n        regexp: /\\u0049|\\u004A|\\u012E|\\u00CC|\\u00CD|\\u0128/g,\n        map: {\n            I: \"\\u0069\\u0307\",\n            J: \"\\u006A\\u0307\",\n            Į: \"\\u012F\\u0307\",\n            Ì: \"\\u0069\\u0307\\u0300\",\n            Í: \"\\u0069\\u0307\\u0301\",\n            Ĩ: \"\\u0069\\u0307\\u0303\",\n        },\n    },\n};\n/**\n * Localized lower case.\n */\nexport function localeLowerCase(str, locale) {\n    var lang = SUPPORTED_LOCALE[locale.toLowerCase()];\n    if (lang)\n        return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));\n    return lowerCase(str);\n}\n/**\n * Lower case as a function.\n */\nexport function lowerCase(str) {\n    return str.toLowerCase();\n}\n//# sourceMappingURL=index.js.map","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n","import { lowerCase } from \"lower-case\";\n// Support camel case (\"camelCase\" -> \"camel Case\" and \"CAMELCase\" -> \"CAMEL Case\").\nvar DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];\n// Remove all non-word characters.\nvar DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;\n/**\n * Normalize the string into something other libraries can manipulate easier.\n */\nexport function noCase(input, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? \" \" : _d;\n    var result = replace(replace(input, splitRegexp, \"$1\\0$2\"), stripRegexp, \"\\0\");\n    var start = 0;\n    var end = result.length;\n    // Trim the delimiter from around the output string.\n    while (result.charAt(start) === \"\\0\")\n        start++;\n    while (result.charAt(end - 1) === \"\\0\")\n        end--;\n    // Transform each token independently.\n    return result.slice(start, end).split(\"\\0\").map(transform).join(delimiter);\n}\n/**\n * Replace `re` in the input string with the replacement value.\n */\nfunction replace(input, re, value) {\n    if (re instanceof RegExp)\n        return input.replace(re, value);\n    return re.reduce(function (input, re) { return input.replace(re, value); }, input);\n}\n//# sourceMappingURL=index.js.map","// Copyright Joyent, Inc. and other Node contributors.\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a\r\n// copy of this software and associated documentation files (the\r\n// \"Software\"), to deal in the Software without restriction, including\r\n// without limitation the rights to use, copy, modify, merge, publish,\r\n// distribute, sublicense, and/or sell copies of the Software, and to permit\r\n// persons to whom the Software is furnished to do so, subject to the\r\n// following conditions:\r\n//\r\n// The above copyright notice and this permission notice shall be included\r\n// in all copies or substantial portions of the Software.\r\n//\r\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\r\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\r\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\r\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\r\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n'use strict';\r\n\r\n\r\nvar isWindows = process.platform === 'win32';\r\nvar util = require('util');\r\n\r\n\r\n// resolves . and .. elements in a path array with directory names there\r\n// must be no slashes or device names (c:\\) in the array\r\n// (so also no leading and trailing slashes - it does not distinguish\r\n// relative and absolute paths)\r\nfunction normalizeArray(parts, allowAboveRoot) {\r\n  var res = [];\r\n  for (var i = 0; i < parts.length; i++) {\r\n    var p = parts[i];\r\n\r\n    // ignore empty parts\r\n    if (!p || p === '.')\r\n      continue;\r\n\r\n    if (p === '..') {\r\n      if (res.length && res[res.length - 1] !== '..') {\r\n        res.pop();\r\n      } else if (allowAboveRoot) {\r\n        res.push('..');\r\n      }\r\n    } else {\r\n      res.push(p);\r\n    }\r\n  }\r\n\r\n  return res;\r\n}\r\n\r\n// returns an array with empty elements removed from either end of the input\r\n// array or the original array if no elements need to be removed\r\nfunction trimArray(arr) {\r\n  var lastIndex = arr.length - 1;\r\n  var start = 0;\r\n  for (; start <= lastIndex; start++) {\r\n    if (arr[start])\r\n      break;\r\n  }\r\n\r\n  var end = lastIndex;\r\n  for (; end >= 0; end--) {\r\n    if (arr[end])\r\n      break;\r\n  }\r\n\r\n  if (start === 0 && end === lastIndex)\r\n    return arr;\r\n  if (start > end)\r\n    return [];\r\n  return arr.slice(start, end + 1);\r\n}\r\n\r\n// Regex to split a windows path into three parts: [*, device, slash,\r\n// tail] windows-only\r\nvar splitDeviceRe =\r\n    /^([a-zA-Z]:|[\\\\\\/]{2}[^\\\\\\/]+[\\\\\\/]+[^\\\\\\/]+)?([\\\\\\/])?([\\s\\S]*?)$/;\r\n\r\n// Regex to split the tail part of the above into [*, dir, basename, ext]\r\nvar splitTailRe =\r\n    /^([\\s\\S]*?)((?:\\.{1,2}|[^\\\\\\/]+?|)(\\.[^.\\/\\\\]*|))(?:[\\\\\\/]*)$/;\r\n\r\nvar win32 = {};\r\n\r\n// Function to split a filename into [root, dir, basename, ext]\r\nfunction win32SplitPath(filename) {\r\n  // Separate device+slash from tail\r\n  var result = splitDeviceRe.exec(filename),\r\n      device = (result[1] || '') + (result[2] || ''),\r\n      tail = result[3] || '';\r\n  // Split the tail into dir, basename and extension\r\n  var result2 = splitTailRe.exec(tail),\r\n      dir = result2[1],\r\n      basename = result2[2],\r\n      ext = result2[3];\r\n  return [device, dir, basename, ext];\r\n}\r\n\r\nfunction win32StatPath(path) {\r\n  var result = splitDeviceRe.exec(path),\r\n      device = result[1] || '',\r\n      isUnc = !!device && device[1] !== ':';\r\n  return {\r\n    device: device,\r\n    isUnc: isUnc,\r\n    isAbsolute: isUnc || !!result[2], // UNC paths are always absolute\r\n    tail: result[3]\r\n  };\r\n}\r\n\r\nfunction normalizeUNCRoot(device) {\r\n  return '\\\\\\\\' + device.replace(/^[\\\\\\/]+/, '').replace(/[\\\\\\/]+/g, '\\\\');\r\n}\r\n\r\n// path.resolve([from ...], to)\r\nwin32.resolve = function() {\r\n  var resolvedDevice = '',\r\n      resolvedTail = '',\r\n      resolvedAbsolute = false;\r\n\r\n  for (var i = arguments.length - 1; i >= -1; i--) {\r\n    var path;\r\n    if (i >= 0) {\r\n      path = arguments[i];\r\n    } else if (!resolvedDevice) {\r\n      path = process.cwd();\r\n    } else {\r\n      // Windows has the concept of drive-specific current working\r\n      // directories. If we've resolved a drive letter but not yet an\r\n      // absolute path, get cwd for that drive. We're sure the device is not\r\n      // an unc path at this points, because unc paths are always absolute.\r\n      path = process.env['=' + resolvedDevice];\r\n      // Verify that a drive-local cwd was found and that it actually points\r\n      // to our drive. If not, default to the drive's root.\r\n      if (!path || path.substr(0, 3).toLowerCase() !==\r\n          resolvedDevice.toLowerCase() + '\\\\') {\r\n        path = resolvedDevice + '\\\\';\r\n      }\r\n    }\r\n\r\n    // Skip empty and invalid entries\r\n    if (!util.isString(path)) {\r\n      throw new TypeError('Arguments to path.resolve must be strings');\r\n    } else if (!path) {\r\n      continue;\r\n    }\r\n\r\n    var result = win32StatPath(path),\r\n        device = result.device,\r\n        isUnc = result.isUnc,\r\n        isAbsolute = result.isAbsolute,\r\n        tail = result.tail;\r\n\r\n    if (device &&\r\n        resolvedDevice &&\r\n        device.toLowerCase() !== resolvedDevice.toLowerCase()) {\r\n      // This path points to another device so it is not applicable\r\n      continue;\r\n    }\r\n\r\n    if (!resolvedDevice) {\r\n      resolvedDevice = device;\r\n    }\r\n    if (!resolvedAbsolute) {\r\n      resolvedTail = tail + '\\\\' + resolvedTail;\r\n      resolvedAbsolute = isAbsolute;\r\n    }\r\n\r\n    if (resolvedDevice && resolvedAbsolute) {\r\n      break;\r\n    }\r\n  }\r\n\r\n  // Convert slashes to backslashes when `resolvedDevice` points to an UNC\r\n  // root. Also squash multiple slashes into a single one where appropriate.\r\n  if (isUnc) {\r\n    resolvedDevice = normalizeUNCRoot(resolvedDevice);\r\n  }\r\n\r\n  // At this point the path should be resolved to a full absolute path,\r\n  // but handle relative paths to be safe (might happen when process.cwd()\r\n  // fails)\r\n\r\n  // Normalize the tail path\r\n  resolvedTail = normalizeArray(resolvedTail.split(/[\\\\\\/]+/),\r\n                                !resolvedAbsolute).join('\\\\');\r\n\r\n  return (resolvedDevice + (resolvedAbsolute ? '\\\\' : '') + resolvedTail) ||\r\n         '.';\r\n};\r\n\r\n\r\nwin32.normalize = function(path) {\r\n  var result = win32StatPath(path),\r\n      device = result.device,\r\n      isUnc = result.isUnc,\r\n      isAbsolute = result.isAbsolute,\r\n      tail = result.tail,\r\n      trailingSlash = /[\\\\\\/]$/.test(tail);\r\n\r\n  // Normalize the tail path\r\n  tail = normalizeArray(tail.split(/[\\\\\\/]+/), !isAbsolute).join('\\\\');\r\n\r\n  if (!tail && !isAbsolute) {\r\n    tail = '.';\r\n  }\r\n  if (tail && trailingSlash) {\r\n    tail += '\\\\';\r\n  }\r\n\r\n  // Convert slashes to backslashes when `device` points to an UNC root.\r\n  // Also squash multiple slashes into a single one where appropriate.\r\n  if (isUnc) {\r\n    device = normalizeUNCRoot(device);\r\n  }\r\n\r\n  return device + (isAbsolute ? '\\\\' : '') + tail;\r\n};\r\n\r\n\r\nwin32.isAbsolute = function(path) {\r\n  return win32StatPath(path).isAbsolute;\r\n};\r\n\r\nwin32.join = function() {\r\n  var paths = [];\r\n  for (var i = 0; i < arguments.length; i++) {\r\n    var arg = arguments[i];\r\n    if (!util.isString(arg)) {\r\n      throw new TypeError('Arguments to path.join must be strings');\r\n    }\r\n    if (arg) {\r\n      paths.push(arg);\r\n    }\r\n  }\r\n\r\n  var joined = paths.join('\\\\');\r\n\r\n  // Make sure that the joined path doesn't start with two slashes, because\r\n  // normalize() will mistake it for an UNC path then.\r\n  //\r\n  // This step is skipped when it is very clear that the user actually\r\n  // intended to point at an UNC path. This is assumed when the first\r\n  // non-empty string arguments starts with exactly two slashes followed by\r\n  // at least one more non-slash character.\r\n  //\r\n  // Note that for normalize() to treat a path as an UNC path it needs to\r\n  // have at least 2 components, so we don't filter for that here.\r\n  // This means that the user can use join to construct UNC paths from\r\n  // a server name and a share name; for example:\r\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\')\r\n  if (!/^[\\\\\\/]{2}[^\\\\\\/]/.test(paths[0])) {\r\n    joined = joined.replace(/^[\\\\\\/]{2,}/, '\\\\');\r\n  }\r\n\r\n  return win32.normalize(joined);\r\n};\r\n\r\n\r\n// path.relative(from, to)\r\n// it will solve the relative path from 'from' to 'to', for instance:\r\n// from = 'C:\\\\orandea\\\\test\\\\aaa'\r\n// to = 'C:\\\\orandea\\\\impl\\\\bbb'\r\n// The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\r\nwin32.relative = function(from, to) {\r\n  from = win32.resolve(from);\r\n  to = win32.resolve(to);\r\n\r\n  // windows is not case sensitive\r\n  var lowerFrom = from.toLowerCase();\r\n  var lowerTo = to.toLowerCase();\r\n\r\n  var toParts = trimArray(to.split('\\\\'));\r\n\r\n  var lowerFromParts = trimArray(lowerFrom.split('\\\\'));\r\n  var lowerToParts = trimArray(lowerTo.split('\\\\'));\r\n\r\n  var length = Math.min(lowerFromParts.length, lowerToParts.length);\r\n  var samePartsLength = length;\r\n  for (var i = 0; i < length; i++) {\r\n    if (lowerFromParts[i] !== lowerToParts[i]) {\r\n      samePartsLength = i;\r\n      break;\r\n    }\r\n  }\r\n\r\n  if (samePartsLength == 0) {\r\n    return to;\r\n  }\r\n\r\n  var outputParts = [];\r\n  for (var i = samePartsLength; i < lowerFromParts.length; i++) {\r\n    outputParts.push('..');\r\n  }\r\n\r\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\r\n\r\n  return outputParts.join('\\\\');\r\n};\r\n\r\n\r\nwin32._makeLong = function(path) {\r\n  // Note: this will *probably* throw somewhere.\r\n  if (!util.isString(path))\r\n    return path;\r\n\r\n  if (!path) {\r\n    return '';\r\n  }\r\n\r\n  var resolvedPath = win32.resolve(path);\r\n\r\n  if (/^[a-zA-Z]\\:\\\\/.test(resolvedPath)) {\r\n    // path is local filesystem path, which needs to be converted\r\n    // to long UNC path.\r\n    return '\\\\\\\\?\\\\' + resolvedPath;\r\n  } else if (/^\\\\\\\\[^?.]/.test(resolvedPath)) {\r\n    // path is network UNC path, which needs to be converted\r\n    // to long UNC path.\r\n    return '\\\\\\\\?\\\\UNC\\\\' + resolvedPath.substring(2);\r\n  }\r\n\r\n  return path;\r\n};\r\n\r\n\r\nwin32.dirname = function(path) {\r\n  var result = win32SplitPath(path),\r\n      root = result[0],\r\n      dir = result[1];\r\n\r\n  if (!root && !dir) {\r\n    // No dirname whatsoever\r\n    return '.';\r\n  }\r\n\r\n  if (dir) {\r\n    // It has a dirname, strip trailing slash\r\n    dir = dir.substr(0, dir.length - 1);\r\n  }\r\n\r\n  return root + dir;\r\n};\r\n\r\n\r\nwin32.basename = function(path, ext) {\r\n  var f = win32SplitPath(path)[2];\r\n  // TODO: make this comparison case-insensitive on windows?\r\n  if (ext && f.substr(-1 * ext.length) === ext) {\r\n    f = f.substr(0, f.length - ext.length);\r\n  }\r\n  return f;\r\n};\r\n\r\n\r\nwin32.extname = function(path) {\r\n  return win32SplitPath(path)[3];\r\n};\r\n\r\n\r\nwin32.format = function(pathObject) {\r\n  if (!util.isObject(pathObject)) {\r\n    throw new TypeError(\r\n        \"Parameter 'pathObject' must be an object, not \" + typeof pathObject\r\n    );\r\n  }\r\n\r\n  var root = pathObject.root || '';\r\n\r\n  if (!util.isString(root)) {\r\n    throw new TypeError(\r\n        \"'pathObject.root' must be a string or undefined, not \" +\r\n        typeof pathObject.root\r\n    );\r\n  }\r\n\r\n  var dir = pathObject.dir;\r\n  var base = pathObject.base || '';\r\n  if (!dir) {\r\n    return base;\r\n  }\r\n  if (dir[dir.length - 1] === win32.sep) {\r\n    return dir + base;\r\n  }\r\n  return dir + win32.sep + base;\r\n};\r\n\r\n\r\nwin32.parse = function(pathString) {\r\n  if (!util.isString(pathString)) {\r\n    throw new TypeError(\r\n        \"Parameter 'pathString' must be a string, not \" + typeof pathString\r\n    );\r\n  }\r\n  var allParts = win32SplitPath(pathString);\r\n  if (!allParts || allParts.length !== 4) {\r\n    throw new TypeError(\"Invalid path '\" + pathString + \"'\");\r\n  }\r\n  return {\r\n    root: allParts[0],\r\n    dir: allParts[0] + allParts[1].slice(0, -1),\r\n    base: allParts[2],\r\n    ext: allParts[3],\r\n    name: allParts[2].slice(0, allParts[2].length - allParts[3].length)\r\n  };\r\n};\r\n\r\n\r\nwin32.sep = '\\\\';\r\nwin32.delimiter = ';';\r\n\r\n\r\n// Split a filename into [root, dir, basename, ext], unix version\r\n// 'root' is just a slash, or nothing.\r\nvar splitPathRe =\r\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\r\nvar posix = {};\r\n\r\n\r\nfunction posixSplitPath(filename) {\r\n  return splitPathRe.exec(filename).slice(1);\r\n}\r\n\r\n\r\n// path.resolve([from ...], to)\r\n// posix version\r\nposix.resolve = function() {\r\n  var resolvedPath = '',\r\n      resolvedAbsolute = false;\r\n\r\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\r\n    var path = (i >= 0) ? arguments[i] : process.cwd();\r\n\r\n    // Skip empty and invalid entries\r\n    if (!util.isString(path)) {\r\n      throw new TypeError('Arguments to path.resolve must be strings');\r\n    } else if (!path) {\r\n      continue;\r\n    }\r\n\r\n    resolvedPath = path + '/' + resolvedPath;\r\n    resolvedAbsolute = path[0] === '/';\r\n  }\r\n\r\n  // At this point the path should be resolved to a full absolute path, but\r\n  // handle relative paths to be safe (might happen when process.cwd() fails)\r\n\r\n  // Normalize the path\r\n  resolvedPath = normalizeArray(resolvedPath.split('/'),\r\n                                !resolvedAbsolute).join('/');\r\n\r\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\r\n};\r\n\r\n// path.normalize(path)\r\n// posix version\r\nposix.normalize = function(path) {\r\n  var isAbsolute = posix.isAbsolute(path),\r\n      trailingSlash = path && path[path.length - 1] === '/';\r\n\r\n  // Normalize the path\r\n  path = normalizeArray(path.split('/'), !isAbsolute).join('/');\r\n\r\n  if (!path && !isAbsolute) {\r\n    path = '.';\r\n  }\r\n  if (path && trailingSlash) {\r\n    path += '/';\r\n  }\r\n\r\n  return (isAbsolute ? '/' : '') + path;\r\n};\r\n\r\n// posix version\r\nposix.isAbsolute = function(path) {\r\n  return path.charAt(0) === '/';\r\n};\r\n\r\n// posix version\r\nposix.join = function() {\r\n  var path = '';\r\n  for (var i = 0; i < arguments.length; i++) {\r\n    var segment = arguments[i];\r\n    if (!util.isString(segment)) {\r\n      throw new TypeError('Arguments to path.join must be strings');\r\n    }\r\n    if (segment) {\r\n      if (!path) {\r\n        path += segment;\r\n      } else {\r\n        path += '/' + segment;\r\n      }\r\n    }\r\n  }\r\n  return posix.normalize(path);\r\n};\r\n\r\n\r\n// path.relative(from, to)\r\n// posix version\r\nposix.relative = function(from, to) {\r\n  from = posix.resolve(from).substr(1);\r\n  to = posix.resolve(to).substr(1);\r\n\r\n  var fromParts = trimArray(from.split('/'));\r\n  var toParts = trimArray(to.split('/'));\r\n\r\n  var length = Math.min(fromParts.length, toParts.length);\r\n  var samePartsLength = length;\r\n  for (var i = 0; i < length; i++) {\r\n    if (fromParts[i] !== toParts[i]) {\r\n      samePartsLength = i;\r\n      break;\r\n    }\r\n  }\r\n\r\n  var outputParts = [];\r\n  for (var i = samePartsLength; i < fromParts.length; i++) {\r\n    outputParts.push('..');\r\n  }\r\n\r\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\r\n\r\n  return outputParts.join('/');\r\n};\r\n\r\n\r\nposix._makeLong = function(path) {\r\n  return path;\r\n};\r\n\r\n\r\nposix.dirname = function(path) {\r\n  var result = posixSplitPath(path),\r\n      root = result[0],\r\n      dir = result[1];\r\n\r\n  if (!root && !dir) {\r\n    // No dirname whatsoever\r\n    return '.';\r\n  }\r\n\r\n  if (dir) {\r\n    // It has a dirname, strip trailing slash\r\n    dir = dir.substr(0, dir.length - 1);\r\n  }\r\n\r\n  return root + dir;\r\n};\r\n\r\n\r\nposix.basename = function(path, ext) {\r\n  var f = posixSplitPath(path)[2];\r\n  // TODO: make this comparison case-insensitive on windows?\r\n  if (ext && f.substr(-1 * ext.length) === ext) {\r\n    f = f.substr(0, f.length - ext.length);\r\n  }\r\n  return f;\r\n};\r\n\r\n\r\nposix.extname = function(path) {\r\n  return posixSplitPath(path)[3];\r\n};\r\n\r\n\r\nposix.format = function(pathObject) {\r\n  if (!util.isObject(pathObject)) {\r\n    throw new TypeError(\r\n        \"Parameter 'pathObject' must be an object, not \" + typeof pathObject\r\n    );\r\n  }\r\n\r\n  var root = pathObject.root || '';\r\n\r\n  if (!util.isString(root)) {\r\n    throw new TypeError(\r\n        \"'pathObject.root' must be a string or undefined, not \" +\r\n        typeof pathObject.root\r\n    );\r\n  }\r\n\r\n  var dir = pathObject.dir ? pathObject.dir + posix.sep : '';\r\n  var base = pathObject.base || '';\r\n  return dir + base;\r\n};\r\n\r\n\r\nposix.parse = function(pathString) {\r\n  if (!util.isString(pathString)) {\r\n    throw new TypeError(\r\n        \"Parameter 'pathString' must be a string, not \" + typeof pathString\r\n    );\r\n  }\r\n  var allParts = posixSplitPath(pathString);\r\n  if (!allParts || allParts.length !== 4) {\r\n    throw new TypeError(\"Invalid path '\" + pathString + \"'\");\r\n  }\r\n  allParts[1] = allParts[1] || '';\r\n  allParts[2] = allParts[2] || '';\r\n  allParts[3] = allParts[3] || '';\r\n\r\n  return {\r\n    root: allParts[0],\r\n    dir: allParts[0] + allParts[1].slice(0, -1),\r\n    base: allParts[2],\r\n    ext: allParts[3],\r\n    name: allParts[2].slice(0, allParts[2].length - allParts[3].length)\r\n  };\r\n};\r\n\r\n\r\nposix.sep = '/';\r\nposix.delimiter = ':';\r\n\r\n\r\nif (isWindows)\r\n  module.exports = win32;\r\nelse /* posix */\r\n  module.exports = posix;\r\n\r\nmodule.exports.posix = posix;\r\nmodule.exports.win32 = win32;\r\n","/**\n  postmate - A powerful, simple, promise-based postMessage library\n  @version v1.5.2\n  @link https://github.com/dollarshaveclub/postmate\n  @author Jacob Kelley <jakie8@gmail.com>\n  @license MIT\n**/\n/**\n * The type of messages our frames our sending\n * @type {String}\n */\nvar messageType = 'application/x-postmate-v1+json';\n/**\n * The maximum number of attempts to send a handshake request to the parent\n * @type {Number}\n */\n\nvar maxHandshakeRequests = 5;\n/**\n * A unique message ID that is used to ensure responses are sent to the correct requests\n * @type {Number}\n */\n\nvar _messageId = 0;\n/**\n * Increments and returns a message ID\n * @return {Number} A unique ID for a message\n */\n\nvar generateNewMessageId = function generateNewMessageId() {\n  return ++_messageId;\n};\n/**\n * Postmate logging function that enables/disables via config\n * @param  {Object} ...args Rest Arguments\n */\n\nvar log = function log() {\n  var _console;\n\n  return Postmate.debug ? (_console = console).log.apply(_console, arguments) : null;\n}; // eslint-disable-line no-console\n\n/**\n * Takes a URL and returns the origin\n * @param  {String} url The full URL being requested\n * @return {String}     The URLs origin\n */\n\nvar resolveOrigin = function resolveOrigin(url) {\n  var a = document.createElement('a');\n  a.href = url;\n  var protocol = a.protocol.length > 4 ? a.protocol : window.location.protocol;\n  var host = a.host.length ? a.port === '80' || a.port === '443' ? a.hostname : a.host : window.location.host;\n  return a.origin || protocol + \"//\" + host;\n};\nvar messageTypes = {\n  handshake: 1,\n  'handshake-reply': 1,\n  call: 1,\n  emit: 1,\n  reply: 1,\n  request: 1\n  /**\n   * Ensures that a message is safe to interpret\n   * @param  {Object} message The postmate message being sent\n   * @param  {String|Boolean} allowedOrigin The whitelisted origin or false to skip origin check\n   * @return {Boolean}\n   */\n\n};\nvar sanitize = function sanitize(message, allowedOrigin) {\n  if (typeof allowedOrigin === 'string' && message.origin !== allowedOrigin) return false;\n  if (!message.data) return false;\n  if (typeof message.data === 'object' && !('postmate' in message.data)) return false;\n  if (message.data.type !== messageType) return false;\n  if (!messageTypes[message.data.postmate]) return false;\n  return true;\n};\n/**\n * Takes a model, and searches for a value by the property\n * @param  {Object} model     The dictionary to search against\n * @param  {String} property  A path within a dictionary (i.e. 'window.location.href')\n * @param  {Object} data      Additional information from the get request that is\n *                            passed to functions in the child model\n * @return {Promise}\n */\n\nvar resolveValue = function resolveValue(model, property) {\n  var unwrappedContext = typeof model[property] === 'function' ? model[property]() : model[property];\n  return Postmate.Promise.resolve(unwrappedContext);\n};\n/**\n * Composes an API to be used by the parent\n * @param {Object} info Information on the consumer\n */\n\nvar ParentAPI =\n/*#__PURE__*/\nfunction () {\n  function ParentAPI(info) {\n    var _this = this;\n\n    this.parent = info.parent;\n    this.frame = info.frame;\n    this.child = info.child;\n    this.childOrigin = info.childOrigin;\n    this.events = {};\n\n    if (process.env.NODE_ENV !== 'production') {\n      log('Parent: Registering API');\n      log('Parent: Awaiting messages...');\n    }\n\n    this.listener = function (e) {\n      if (!sanitize(e, _this.childOrigin)) return false;\n      /**\n       * the assignments below ensures that e, data, and value are all defined\n       */\n\n      var _ref = ((e || {}).data || {}).value || {},\n          data = _ref.data,\n          name = _ref.name;\n\n      if (e.data.postmate === 'emit') {\n        if (process.env.NODE_ENV !== 'production') {\n          log(\"Parent: Received event emission: \" + name);\n        }\n\n        if (name in _this.events) {\n          _this.events[name].call(_this, data);\n        }\n      }\n    };\n\n    this.parent.addEventListener('message', this.listener, false);\n\n    if (process.env.NODE_ENV !== 'production') {\n      log('Parent: Awaiting event emissions from Child');\n    }\n  }\n\n  var _proto = ParentAPI.prototype;\n\n  _proto.get = function get(property) {\n    var _this2 = this;\n\n    return new Postmate.Promise(function (resolve) {\n      // Extract data from response and kill listeners\n      var uid = generateNewMessageId();\n\n      var transact = function transact(e) {\n        if (e.data.uid === uid && e.data.postmate === 'reply') {\n          _this2.parent.removeEventListener('message', transact, false);\n\n          resolve(e.data.value);\n        }\n      }; // Prepare for response from Child...\n\n\n      _this2.parent.addEventListener('message', transact, false); // Then ask child for information\n\n\n      _this2.child.postMessage({\n        postmate: 'request',\n        type: messageType,\n        property: property,\n        uid: uid\n      }, _this2.childOrigin);\n    });\n  };\n\n  _proto.call = function call(property, data) {\n    // Send information to the child\n    this.child.postMessage({\n      postmate: 'call',\n      type: messageType,\n      property: property,\n      data: data\n    }, this.childOrigin);\n  };\n\n  _proto.on = function on(eventName, callback) {\n    this.events[eventName] = callback;\n  };\n\n  _proto.destroy = function destroy() {\n    if (process.env.NODE_ENV !== 'production') {\n      log('Parent: Destroying Postmate instance');\n    }\n\n    window.removeEventListener('message', this.listener, false);\n    this.frame.parentNode.removeChild(this.frame);\n  };\n\n  return ParentAPI;\n}();\n/**\n * Composes an API to be used by the child\n * @param {Object} info Information on the consumer\n */\n\nvar ChildAPI =\n/*#__PURE__*/\nfunction () {\n  function ChildAPI(info) {\n    var _this3 = this;\n\n    this.model = info.model;\n    this.parent = info.parent;\n    this.parentOrigin = info.parentOrigin;\n    this.child = info.child;\n\n    if (process.env.NODE_ENV !== 'production') {\n      log('Child: Registering API');\n      log('Child: Awaiting messages...');\n    }\n\n    this.child.addEventListener('message', function (e) {\n      if (!sanitize(e, _this3.parentOrigin)) return;\n\n      if (process.env.NODE_ENV !== 'production') {\n        log('Child: Received request', e.data);\n      }\n\n      var _e$data = e.data,\n          property = _e$data.property,\n          uid = _e$data.uid,\n          data = _e$data.data;\n\n      if (e.data.postmate === 'call') {\n        if (property in _this3.model && typeof _this3.model[property] === 'function') {\n          _this3.model[property](data);\n        }\n\n        return;\n      } // Reply to Parent\n\n\n      resolveValue(_this3.model, property).then(function (value) {\n        return e.source.postMessage({\n          property: property,\n          postmate: 'reply',\n          type: messageType,\n          uid: uid,\n          value: value\n        }, e.origin);\n      });\n    });\n  }\n\n  var _proto2 = ChildAPI.prototype;\n\n  _proto2.emit = function emit(name, data) {\n    if (process.env.NODE_ENV !== 'production') {\n      log(\"Child: Emitting Event \\\"\" + name + \"\\\"\", data);\n    }\n\n    this.parent.postMessage({\n      postmate: 'emit',\n      type: messageType,\n      value: {\n        name: name,\n        data: data\n      }\n    }, this.parentOrigin);\n  };\n\n  return ChildAPI;\n}();\n/**\n  * The entry point of the Parent.\n * @type {Class}\n */\n\nvar Postmate =\n/*#__PURE__*/\nfunction () {\n  // eslint-disable-line no-undef\n  // Internet Explorer craps itself\n\n  /**\n   * Sets options related to the Parent\n   * @param {Object} object The element to inject the frame into, and the url\n   * @return {Promise}\n   */\n  function Postmate(_ref2) {\n    var _ref2$container = _ref2.container,\n        container = _ref2$container === void 0 ? typeof container !== 'undefined' ? container : document.body : _ref2$container,\n        model = _ref2.model,\n        url = _ref2.url,\n        name = _ref2.name,\n        _ref2$classListArray = _ref2.classListArray,\n        classListArray = _ref2$classListArray === void 0 ? [] : _ref2$classListArray;\n    // eslint-disable-line no-undef\n    this.parent = window;\n    this.frame = document.createElement('iframe');\n    this.frame.name = name || '';\n    this.frame.classList.add.apply(this.frame.classList, classListArray);\n    container.appendChild(this.frame);\n    this.child = this.frame.contentWindow || this.frame.contentDocument.parentWindow;\n    this.model = model || {};\n    return this.sendHandshake(url);\n  }\n  /**\n   * Begins the handshake strategy\n   * @param  {String} url The URL to send a handshake request to\n   * @return {Promise}     Promise that resolves when the handshake is complete\n   */\n\n\n  var _proto3 = Postmate.prototype;\n\n  _proto3.sendHandshake = function sendHandshake(url) {\n    var _this4 = this;\n\n    var childOrigin = resolveOrigin(url);\n    var attempt = 0;\n    var responseInterval;\n    return new Postmate.Promise(function (resolve, reject) {\n      var reply = function reply(e) {\n        if (!sanitize(e, childOrigin)) return false;\n\n        if (e.data.postmate === 'handshake-reply') {\n          clearInterval(responseInterval);\n\n          if (process.env.NODE_ENV !== 'production') {\n            log('Parent: Received handshake reply from Child');\n          }\n\n          _this4.parent.removeEventListener('message', reply, false);\n\n          _this4.childOrigin = e.origin;\n\n          if (process.env.NODE_ENV !== 'production') {\n            log('Parent: Saving Child origin', _this4.childOrigin);\n          }\n\n          return resolve(new ParentAPI(_this4));\n        } // Might need to remove since parent might be receiving different messages\n        // from different hosts\n\n\n        if (process.env.NODE_ENV !== 'production') {\n          log('Parent: Invalid handshake reply');\n        }\n\n        return reject('Failed handshake');\n      };\n\n      _this4.parent.addEventListener('message', reply, false);\n\n      var doSend = function doSend() {\n        attempt++;\n\n        if (process.env.NODE_ENV !== 'production') {\n          log(\"Parent: Sending handshake attempt \" + attempt, {\n            childOrigin: childOrigin\n          });\n        }\n\n        _this4.child.postMessage({\n          postmate: 'handshake',\n          type: messageType,\n          model: _this4.model\n        }, childOrigin);\n\n        if (attempt === maxHandshakeRequests) {\n          clearInterval(responseInterval);\n        }\n      };\n\n      var loaded = function loaded() {\n        doSend();\n        responseInterval = setInterval(doSend, 500);\n      };\n\n      if (_this4.frame.attachEvent) {\n        _this4.frame.attachEvent('onload', loaded);\n      } else {\n        _this4.frame.onload = loaded;\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        log('Parent: Loading frame', {\n          url: url\n        });\n      }\n\n      _this4.frame.src = url;\n    });\n  };\n\n  return Postmate;\n}();\n/**\n * The entry point of the Child\n * @type {Class}\n */\n\n\nPostmate.debug = false;\n\nPostmate.Promise = function () {\n  try {\n    return window ? window.Promise : Promise;\n  } catch (e) {\n    return null;\n  }\n}();\n\nPostmate.Model =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Initializes the child, model, parent, and responds to the Parents handshake\n   * @param {Object} model Hash of values, functions, or promises\n   * @return {Promise}       The Promise that resolves when the handshake has been received\n   */\n  function Model(model) {\n    this.child = window;\n    this.model = model;\n    this.parent = this.child.parent;\n    return this.sendHandshakeReply();\n  }\n  /**\n   * Responds to a handshake initiated by the Parent\n   * @return {Promise} Resolves an object that exposes an API for the Child\n   */\n\n\n  var _proto4 = Model.prototype;\n\n  _proto4.sendHandshakeReply = function sendHandshakeReply() {\n    var _this5 = this;\n\n    return new Postmate.Promise(function (resolve, reject) {\n      var shake = function shake(e) {\n        if (!e.data.postmate) {\n          return;\n        }\n\n        if (e.data.postmate === 'handshake') {\n          if (process.env.NODE_ENV !== 'production') {\n            log('Child: Received handshake from Parent');\n          }\n\n          _this5.child.removeEventListener('message', shake, false);\n\n          if (process.env.NODE_ENV !== 'production') {\n            log('Child: Sending handshake reply to Parent');\n          }\n\n          e.source.postMessage({\n            postmate: 'handshake-reply',\n            type: messageType\n          }, e.origin);\n          _this5.parentOrigin = e.origin; // Extend model with the one provided by the parent\n\n          var defaults = e.data.model;\n\n          if (defaults) {\n            Object.keys(defaults).forEach(function (key) {\n              _this5.model[key] = defaults[key];\n            });\n\n            if (process.env.NODE_ENV !== 'production') {\n              log('Child: Inherited and extended model from Parent');\n            }\n          }\n\n          if (process.env.NODE_ENV !== 'production') {\n            log('Child: Saving Parent origin', _this5.parentOrigin);\n          }\n\n          return resolve(new ChildAPI(_this5));\n        }\n\n        return reject('Handshake Reply Failed');\n      };\n\n      _this5.child.addEventListener('message', shake, false);\n    });\n  };\n\n  return Model;\n}();\n\nexport default Postmate;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","import { __assign } from \"tslib\";\nimport { dotCase } from \"dot-case\";\nexport function snakeCase(input, options) {\n    if (options === void 0) { options = {}; }\n    return dotCase(input, __assign({ delimiter: \"_\" }, options));\n}\n//# sourceMappingURL=index.js.map","import Postmate from 'postmate';\nimport EventEmitter from 'eventemitter3';\nimport Debug from 'debug';\nimport { deferred } from './helpers';\nimport { LSPluginShadowFrame } from './LSPlugin.shadow';\nconst debug = Debug('LSPlugin:caller');\nexport const FLAG_AWAIT = '#await#response#';\nexport const LSPMSG = '#lspmsg#';\nexport const LSPMSG_ERROR_TAG = '#lspmsg#error#';\nexport const LSPMSG_SETTINGS = '#lspmsg#settings#';\nexport const LSPMSG_BEFORE_UNLOAD = '#lspmsg#beforeunload#';\nexport const LSPMSG_SYNC = '#lspmsg#reply#';\nexport const LSPMSG_READY = '#lspmsg#ready#';\nexport const LSPMSGFn = (id) => `${LSPMSG}${id}`;\nexport const AWAIT_LSPMSGFn = (id) => `${FLAG_AWAIT}${id}`;\n/**\n * Call between core and user\n */\nclass LSPluginCaller extends EventEmitter {\n    constructor(_pluginLocal) {\n        super();\n        this._pluginLocal = _pluginLocal;\n        this._connected = false;\n        this._userModel = {};\n        this._debugTag = '';\n        if (_pluginLocal) {\n            this._debugTag = _pluginLocal.debugTag;\n        }\n    }\n    async connectToChild() {\n        if (this._connected)\n            return;\n        const { shadow } = this._pluginLocal;\n        if (shadow) {\n            await this._setupShadowSandbox();\n        }\n        else {\n            await this._setupIframeSandbox();\n        }\n    }\n    async connectToParent(userModel = {}) {\n        if (this._connected)\n            return;\n        const caller = this;\n        const isShadowMode = this._pluginLocal != null;\n        let syncGCTimer = 0;\n        let syncTag = 0;\n        const syncActors = new Map();\n        const readyDeferred = deferred(1000 * 5);\n        const model = this._extendUserModel({\n            [LSPMSG_READY]: async () => {\n                await readyDeferred.resolve();\n            },\n            [LSPMSG_BEFORE_UNLOAD]: async (e) => {\n                const actor = deferred(10 * 1000);\n                caller.emit('beforeunload', Object.assign({ actor }, e));\n                await actor.promise;\n            },\n            [LSPMSG_SETTINGS]: async ({ type, payload }) => {\n                caller.emit('settings:changed', payload);\n            },\n            [LSPMSG]: async ({ ns, type, payload }) => {\n                debug(`${this._debugTag} [call from host]`, ns, type, payload);\n                if (ns && ns.startsWith('hook')) {\n                    caller.emit(`${ns}:${type}`, payload);\n                    return;\n                }\n                caller.emit(type, payload);\n            },\n            [LSPMSG_SYNC]: ({ _sync, result }) => {\n                debug(`sync reply #${_sync}`, result);\n                if (syncActors.has(_sync)) {\n                    const actor = syncActors.get(_sync);\n                    if (actor) {\n                        if (result?.hasOwnProperty(LSPMSG_ERROR_TAG)) {\n                            actor.reject(result[LSPMSG_ERROR_TAG]);\n                        }\n                        else {\n                            actor.resolve(result);\n                        }\n                        syncActors.delete(_sync);\n                    }\n                }\n            },\n            ...userModel\n        });\n        if (isShadowMode) {\n            await readyDeferred.promise;\n            return JSON.parse(JSON.stringify(this._pluginLocal?.toJSON()));\n        }\n        const handshake = new Postmate.Model(model);\n        this._status = 'pending';\n        await handshake.then(refParent => {\n            this._child = refParent;\n            this._connected = true;\n            this._call = async (type, payload = {}, actor) => {\n                if (actor) {\n                    const tag = ++syncTag;\n                    syncActors.set(tag, actor);\n                    payload._sync = tag;\n                    actor.setTag(`async call #${tag}`);\n                    debug('async call #', tag);\n                }\n                refParent.emit(LSPMSGFn(model.baseInfo.id), { type, payload });\n                return actor?.promise;\n            };\n            this._callUserModel = async (type, payload) => {\n                try {\n                    model[type](payload);\n                }\n                catch (e) {\n                    debug(`model method #${type} not existed`);\n                }\n            };\n            // actors GC\n            syncGCTimer = setInterval(() => {\n                if (syncActors.size > 100) {\n                    for (const [k, v] of syncActors) {\n                        if (v.settled) {\n                            syncActors.delete(k);\n                        }\n                    }\n                }\n            }, 1000 * 60 * 30);\n        }).finally(() => {\n            this._status = undefined;\n        });\n        await readyDeferred.promise;\n        return model.baseInfo;\n    }\n    async call(type, payload = {}) {\n        return this._call?.call(this, type, payload);\n    }\n    async callAsync(type, payload = {}) {\n        const actor = deferred(1000 * 10);\n        return this._call?.call(this, type, payload, actor);\n    }\n    async callUserModel(type, payload = {}) {\n        return this._callUserModel?.call(this, type, payload);\n    }\n    async _setupIframeSandbox() {\n        const pl = this._pluginLocal;\n        const handshake = new Postmate({\n            container: document.body,\n            url: pl.options.entry,\n            classListArray: ['lsp-iframe-sandbox'],\n            model: { baseInfo: JSON.parse(JSON.stringify(pl.toJSON())) }\n        });\n        this._status = 'pending';\n        // timeout for handshake\n        let timer;\n        return new Promise((resolve, reject) => {\n            timer = setTimeout(() => {\n                reject(new Error(`handshake Timeout`));\n            }, 3 * 1000); // 3secs\n            handshake.then(refChild => {\n                this._parent = refChild;\n                this._connected = true;\n                this.emit('connected');\n                refChild.frame.setAttribute('id', pl.id);\n                refChild.on(LSPMSGFn(pl.id), ({ type, payload }) => {\n                    debug(`[call from plugin] `, type, payload);\n                    this._pluginLocal?.emit(type, payload || {});\n                });\n                this._call = async (...args) => {\n                    // parent all will get message before handshaked\n                    await refChild.call(LSPMSGFn(pl.id), { type: args[0], payload: args[1] || {} });\n                };\n                this._callUserModel = async (type, payload) => {\n                    if (type.startsWith(FLAG_AWAIT)) {\n                        // TODO: attach payload\n                        return await refChild.get(type.replace(FLAG_AWAIT, ''));\n                    }\n                    else {\n                        refChild.call(type, payload);\n                    }\n                };\n                resolve(null);\n            }).catch(e => {\n                reject(e);\n            }).finally(() => {\n                clearTimeout(timer);\n            });\n        }).catch(e => {\n            debug('iframe sandbox error', e);\n            throw e;\n        }).finally(() => {\n            this._status = undefined;\n        });\n    }\n    async _setupShadowSandbox() {\n        const pl = this._pluginLocal;\n        const shadow = this._shadow = new LSPluginShadowFrame(pl);\n        try {\n            this._status = 'pending';\n            await shadow.load();\n            this._connected = true;\n            this.emit('connected');\n            this._call = async (type, payload = {}, actor) => {\n                actor && (payload.actor = actor);\n                // TODO: support sync call\n                // @ts-ignore Call in same thread\n                this._pluginLocal?.emit(type, payload);\n                return actor?.promise;\n            };\n            this._callUserModel = async (...args) => {\n                let type = args[0];\n                if (type?.startsWith(FLAG_AWAIT)) {\n                    type = type.replace(FLAG_AWAIT, '');\n                }\n                const payload = args[1] || {};\n                const fn = this._userModel[type];\n                if (typeof fn === 'function') {\n                    await fn.call(null, payload);\n                }\n            };\n        }\n        catch (e) {\n            debug('shadow sandbox error', e);\n            throw e;\n        }\n        finally {\n            this._status = undefined;\n        }\n    }\n    _extendUserModel(model) {\n        return Object.assign(this._userModel, model);\n    }\n    _getSandboxIframeContainer() {\n        return this._parent?.frame;\n    }\n    _getSandboxShadowContainer() {\n        return this._shadow?.frame;\n    }\n    set debugTag(value) {\n        this._debugTag = value;\n    }\n    async destroy() {\n        if (this._parent) {\n            await this._parent.destroy();\n        }\n        if (this._shadow) {\n            this._shadow.destroy();\n        }\n    }\n}\nexport { LSPluginCaller };\n","import EventEmitter from 'eventemitter3';\nimport { LSPluginUser } from './LSPlugin.user';\n// @ts-ignore\nconst { importHTML, createSandboxContainer } = window.QSandbox || {};\nfunction userFetch(url, opts) {\n    if (!url.startsWith('http')) {\n        url = url.replace('file://', '');\n        return new Promise(async (resolve, reject) => {\n            try {\n                const content = await window.apis.doAction(['readFile', url]);\n                resolve({\n                    text() {\n                        return content;\n                    }\n                });\n            }\n            catch (e) {\n                console.error(e);\n                reject(e);\n            }\n        });\n    }\n    return fetch(url, opts);\n}\nclass LSPluginShadowFrame extends EventEmitter {\n    constructor(_pluginLocal) {\n        super();\n        this._pluginLocal = _pluginLocal;\n        this._loaded = false;\n        this._unmountFns = [];\n        _pluginLocal._dispose(() => {\n            this._unmount();\n        });\n    }\n    async load() {\n        const { name, entry } = this._pluginLocal.options;\n        if (this.loaded || !entry)\n            return;\n        const { template, execScripts } = await importHTML(entry, { fetch: userFetch });\n        this._mount(template, document.body);\n        const sandbox = createSandboxContainer(name, {\n            elementGetter: () => this._root?.firstChild,\n        });\n        const global = sandbox.instance.proxy;\n        global.__shadow_mode__ = true;\n        global.LSPluginLocal = this._pluginLocal;\n        global.LSPluginShadow = this;\n        global.LSPluginUser = global.logseq = new LSPluginUser(this._pluginLocal.toJSON(), this._pluginLocal.caller);\n        // TODO: {mount, unmount}\n        const execResult = await execScripts(global, true);\n        this._unmountFns.push(execResult.unmount);\n        this._loaded = true;\n    }\n    _mount(content, container) {\n        const frame = this._frame = document.createElement('div');\n        frame.classList.add('lsp-shadow-sandbox');\n        frame.id = this._pluginLocal.id;\n        this._root = frame.attachShadow({ mode: 'open' });\n        this._root.innerHTML = `<div>${content}</div>`;\n        container.appendChild(frame);\n        this.emit('mounted');\n    }\n    _unmount() {\n        for (const fn of this._unmountFns) {\n            fn && fn.call(null);\n        }\n    }\n    destroy() {\n        this.frame?.parentNode?.removeChild(this.frame);\n    }\n    get loaded() {\n        return this._loaded;\n    }\n    get document() {\n        return this._root?.firstChild;\n    }\n    get frame() {\n        return this._frame;\n    }\n}\nexport { LSPluginShadowFrame };\n","import { deepMerge } from './helpers';\nimport { LSPluginCaller } from './LSPlugin.caller';\nimport Debug from 'debug';\nimport { snakeCase } from 'snake-case';\nimport EventEmitter from 'eventemitter3';\nconst debug = Debug('LSPlugin:user');\nconst app = {};\nlet registeredCmdUid = 0;\nconst editor = {\n    registerSlashCommand(tag, actions) {\n        debug('Register slash command #', this.baseInfo.id, tag, actions);\n        if (typeof actions === 'function') {\n            actions = [\n                ['editor/clear-current-slash', false],\n                ['editor/restore-saved-cursor'],\n                ['editor/hook', actions]\n            ];\n        }\n        actions = actions.map((it) => {\n            const [tag, ...args] = it;\n            switch (tag) {\n                case 'editor/hook':\n                    let key = args[0];\n                    let fn = () => {\n                        this.caller?.callUserModel(key);\n                    };\n                    if (typeof key === 'function') {\n                        fn = key;\n                    }\n                    const eventKey = `SlashCommandHook${tag}${++registeredCmdUid}`;\n                    it[1] = eventKey;\n                    // register command listener\n                    this.Editor['on' + eventKey](fn);\n                    break;\n                default:\n            }\n            return it;\n        });\n        this.caller?.call(`api:call`, {\n            method: 'register-plugin-slash-command',\n            args: [this.baseInfo.id, [tag, actions]]\n        });\n        return false;\n    },\n    registerBlockContextMenu(tag, action) {\n        if (typeof action !== 'function') {\n            return false;\n        }\n        const key = tag;\n        const label = tag;\n        const type = 'block-context-menu';\n        const eventKey = `SimpleCommandHook${tag}${++registeredCmdUid}`;\n        this.Editor['on' + eventKey](action);\n        this.caller?.call(`api:call`, {\n            method: 'register-plugin-simple-command',\n            args: [this.baseInfo.id, [{ key, label, type }, ['editor/hook', eventKey]]]\n        });\n        return false;\n    }\n};\nconst db = {};\nconst KEY_MAIN_UI = 0;\n/**\n * User plugin instance\n */\nexport class LSPluginUser extends EventEmitter {\n    /**\n     * @param _baseInfo\n     * @param _caller\n     */\n    constructor(_baseInfo, _caller) {\n        super();\n        this._baseInfo = _baseInfo;\n        this._caller = _caller;\n        /**\n         * @private\n         */\n        this._connected = false;\n        /**\n         * ui frame identities\n         * @private\n         */\n        this._ui = new Map();\n        _caller.on('settings:changed', (payload) => {\n            const b = Object.assign({}, this.settings);\n            const a = Object.assign(this._baseInfo.settings, payload);\n            this.emit('settings:changed', { ...a }, b);\n        });\n        _caller.on('beforeunload', async (payload) => {\n            const { actor, ...rest } = payload;\n            const cb = this._beforeunloadCallback;\n            if (!cb || !actor)\n                return;\n            try {\n                cb && await cb(rest);\n                actor.resolve(null);\n            }\n            catch (e) {\n                console.debug(`${_caller.debugTag} [beforeunload] `, e);\n                actor.reject(e);\n            }\n        });\n    }\n    async ready(model, callback) {\n        if (this._connected)\n            return;\n        try {\n            if (typeof model === 'function') {\n                callback = model;\n                model = {};\n            }\n            let baseInfo = await this._caller.connectToParent(model);\n            baseInfo = deepMerge(this._baseInfo, baseInfo);\n            this._connected = true;\n            if (baseInfo?.id) {\n                this._caller.debugTag = `#${baseInfo.id} [${baseInfo.name}]`;\n            }\n            callback && callback.call(this, baseInfo);\n        }\n        catch (e) {\n            console.error('[LSPlugin Ready Error]', e);\n        }\n    }\n    beforeunload(callback) {\n        if (typeof callback !== 'function')\n            return;\n        this._beforeunloadCallback = callback;\n    }\n    provideModel(model) {\n        this.caller._extendUserModel(model);\n        return this;\n    }\n    provideTheme(theme) {\n        this.caller.call('provider:theme', theme);\n        return this;\n    }\n    provideStyle(style) {\n        this.caller.call('provider:style', style);\n        return this;\n    }\n    provideUI(ui) {\n        this.caller.call('provider:ui', ui);\n        return this;\n    }\n    updateSettings(attrs) {\n        this.caller.call('settings:update', attrs);\n        // TODO: update associated baseInfo settings\n    }\n    setMainUIAttrs(attrs) {\n        this.caller.call('main-ui:attrs', attrs);\n    }\n    setMainUIInlineStyle(style) {\n        this.caller.call('main-ui:style', style);\n    }\n    hideMainUI(opts) {\n        const payload = { key: KEY_MAIN_UI, visible: false, cursor: opts?.restoreEditingCursor };\n        this.caller.call('main-ui:visible', payload);\n        this.emit('ui:visible:changed', payload);\n        this._ui.set(payload.key, payload);\n    }\n    showMainUI() {\n        const payload = { key: KEY_MAIN_UI, visible: true };\n        this.caller.call('main-ui:visible', payload);\n        this.emit('ui:visible:changed', payload);\n        this._ui.set(payload.key, payload);\n    }\n    toggleMainUI() {\n        const payload = { key: KEY_MAIN_UI, toggle: true };\n        const state = this._ui.get(payload.key);\n        if (state && state.visible) {\n            this.hideMainUI();\n        }\n        else {\n            this.showMainUI();\n        }\n    }\n    get isMainUIVisible() {\n        const state = this._ui.get(0);\n        return Boolean(state && state.visible);\n    }\n    get connected() {\n        return this._connected;\n    }\n    get baseInfo() {\n        return this._baseInfo;\n    }\n    get settings() {\n        return this.baseInfo?.settings;\n    }\n    get caller() {\n        return this._caller;\n    }\n    _makeUserProxy(target, tag) {\n        const that = this;\n        const caller = this.caller;\n        return new Proxy(target, {\n            get(target, propKey, receiver) {\n                const origMethod = target[propKey];\n                return function (...args) {\n                    if (origMethod) {\n                        const ret = origMethod.apply(that, args);\n                        if (ret === false)\n                            return;\n                    }\n                    // Handle hook\n                    if (tag) {\n                        const hookMatcher = propKey.toString().match(/^(once|off|on)/i);\n                        if (hookMatcher != null) {\n                            const f = hookMatcher[0].toLowerCase();\n                            const s = hookMatcher.input;\n                            const e = s.slice(f.length);\n                            const type = `hook:${tag}:${snakeCase(e)}`;\n                            const handler = args[0];\n                            caller[f](type, handler);\n                            return f !== 'off' ? () => (caller.off(type, handler)) : void 0;\n                        }\n                    }\n                    // Call host\n                    return caller.callAsync(`api:call`, {\n                        method: propKey,\n                        args: args\n                    });\n                };\n            }\n        });\n    }\n    get App() {\n        return this._makeUserProxy(app, 'app');\n    }\n    get Editor() {\n        return this._makeUserProxy(editor, 'editor');\n    }\n    get DB() {\n        return this._makeUserProxy(db);\n    }\n}\nexport function setupPluginUserInstance(pluginBaseInfo, pluginCaller) {\n    return new LSPluginUser(pluginBaseInfo, pluginCaller);\n}\nif (window.__LSP__HOST__ == null) { // Entry of iframe mode\n    const caller = new LSPluginCaller(null);\n    window.logseq = setupPluginUserInstance({}, caller);\n}\n","import { snakeCase } from 'snake-case';\nexport function isObject(item) {\n    return (item === Object(item) && !Array.isArray(item));\n}\nexport function deepMerge(target, ...sources) {\n    // return the target if no sources passed\n    if (!sources.length) {\n        return target;\n    }\n    const result = target;\n    if (isObject(result)) {\n        const len = sources.length;\n        for (let i = 0; i < len; i += 1) {\n            const elm = sources[i];\n            if (isObject(elm)) {\n                for (const key in elm) {\n                    if (elm.hasOwnProperty(key)) {\n                        if (isObject(elm[key])) {\n                            if (!result[key] || !isObject(result[key])) {\n                                result[key] = {};\n                            }\n                            deepMerge(result[key], elm[key]);\n                        }\n                        else {\n                            if (Array.isArray(result[key]) && Array.isArray(elm[key])) {\n                                // concatenate the two arrays and remove any duplicate primitive values\n                                result[key] = Array.from(new Set(result[key].concat(elm[key])));\n                            }\n                            else {\n                                result[key] = elm[key];\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n    return result;\n}\nexport function genID() {\n    // Math.random should be unique because of its seeding algorithm.\n    // Convert it to base 36 (numbers + letters), and grab the first 9 characters\n    // after the decimal.\n    return '_' + Math.random().toString(36).substr(2, 9);\n}\nexport function ucFirst(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\nexport function withFileProtocol(path) {\n    if (!path)\n        return '';\n    const reg = /^(http|file|assets)/;\n    if (!reg.test(path)) {\n        path = 'file://' + path;\n    }\n    return path;\n}\n/**\n * @param timeout milliseconds\n * @param tag string\n */\nexport function deferred(timeout, tag) {\n    let resolve, reject;\n    let settled = false;\n    const timeFn = (r) => {\n        return (v) => {\n            timeout && clearTimeout(timeout);\n            r(v);\n            settled = true;\n        };\n    };\n    const promise = new Promise((resolve1, reject1) => {\n        resolve = timeFn(resolve1);\n        reject = timeFn(reject1);\n        if (timeout) {\n            // @ts-ignore\n            timeout = setTimeout(() => reject(new Error(`[deferred timeout] ${tag}`)), timeout);\n        }\n    });\n    return {\n        created: Date.now(),\n        setTag: (t) => tag = t,\n        resolve, reject, promise,\n        get settled() {\n            return settled;\n        }\n    };\n}\nexport function invokeHostExportedApi(method, ...args) {\n    const method1 = snakeCase(method);\n    // @ts-ignore\n    const logseqHostExportedApi = window.logseq?.api || {};\n    const fn = logseqHostExportedApi[method1] || window.apis[method1] ||\n        logseqHostExportedApi[method] || window.apis[method];\n    if (!fn) {\n        throw new Error(`Not existed method #${method}`);\n    }\n    return typeof fn !== 'function' ? fn : fn.apply(null, args);\n}\nexport function setupIframeSandbox(props, target) {\n    const iframe = document.createElement('iframe');\n    iframe.classList.add('lsp-iframe-sandbox');\n    Object.entries(props).forEach(([k, v]) => {\n        iframe.setAttribute(k, v);\n    });\n    target.appendChild(iframe);\n    return async () => {\n        target.removeChild(iframe);\n    };\n}\nexport function setupInjectedStyle(style, attrs) {\n    const key = attrs['data-injected-style'];\n    let el = key && document.querySelector(`[data-injected-style=${key}]`);\n    if (el) {\n        el.textContent = style;\n        return;\n    }\n    el = document.createElement('style');\n    el.textContent = style;\n    attrs && Object.entries(attrs).forEach(([k, v]) => {\n        el.setAttribute(k, v);\n    });\n    document.head.append(el);\n    return () => {\n        document.head.removeChild(el);\n    };\n}\nexport function setupInjectedUI(ui, attrs) {\n    const pl = this;\n    let selector = '';\n    if ('slot' in ui) {\n        selector = `#${ui.slot}`;\n    }\n    else {\n        selector = ui.path;\n    }\n    const target = selector && document.querySelector(selector);\n    if (!target) {\n        console.error(`${this.debugTag} can not resolve selector target ${selector}`);\n        return;\n    }\n    const key = `${ui.key}-${pl.id}`;\n    let el = document.querySelector(`div[data-injected-ui=\"${key}\"]`);\n    if (el) {\n        el.innerHTML = ui.template;\n        return;\n    }\n    el = document.createElement('div');\n    el.dataset.injectedUi = key || '';\n    // TODO: Support more\n    el.innerHTML = ui.template;\n    attrs && Object.entries(attrs).forEach(([k, v]) => {\n        el.setAttribute(k, v);\n    });\n    target.appendChild(el);\n    // TODO: How handle events\n    ['click', 'focus', 'focusin', 'focusout', 'blur', 'dblclick',\n        'keyup', 'keypress', 'keydown', 'change', 'input'].forEach((type) => {\n        el.addEventListener(type, (e) => {\n            const target = e.target;\n            const trigger = target.closest(`[data-on-${type}]`);\n            if (!trigger)\n                return;\n            const msgType = trigger.dataset[`on${ucFirst(type)}`];\n            msgType && pl.caller?.callUserModel(msgType, transformableEvent(trigger, e));\n        }, false);\n    });\n    return () => {\n        target.removeChild(el);\n    };\n}\nexport function transformableEvent(target, e) {\n    const obj = {};\n    if (target) {\n        const ds = target.dataset;\n        const FLAG_RECT = 'rect';\n        ['value', 'id', 'className',\n            'dataset', FLAG_RECT\n        ].forEach((k) => {\n            let v;\n            switch (k) {\n                case FLAG_RECT:\n                    if (!ds.hasOwnProperty(FLAG_RECT))\n                        return;\n                    v = target.getBoundingClientRect().toJSON();\n                    break;\n                default:\n                    v = target[k];\n            }\n            if (typeof v === 'object') {\n                v = { ...v };\n            }\n            obj[k] = v;\n        });\n    }\n    return obj;\n}\nlet injectedThemeEffect = null;\nexport function setupInjectedTheme(url) {\n    injectedThemeEffect?.call();\n    if (!url)\n        return;\n    const link = document.createElement('link');\n    link.rel = 'stylesheet';\n    link.href = url;\n    document.head.appendChild(link);\n    return (injectedThemeEffect = () => {\n        document.head.removeChild(link);\n        injectedThemeEffect = null;\n    });\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import EventEmitter from 'eventemitter3';\nimport { deepMerge, setupInjectedStyle, genID, setupInjectedTheme, setupInjectedUI, deferred, invokeHostExportedApi, isObject, withFileProtocol } from './helpers';\nimport Debug from 'debug';\nimport { LSPluginCaller, LSPMSG_READY, LSPMSG_SYNC, LSPMSG, LSPMSG_SETTINGS, LSPMSG_ERROR_TAG, LSPMSG_BEFORE_UNLOAD, AWAIT_LSPMSGFn } from './LSPlugin.caller';\nimport { snakeCase } from 'snake-case';\nimport DOMPurify from 'dompurify';\nimport * as path from 'path';\nconst debug = Debug('LSPlugin:core');\n/**\n * User settings\n */\nclass PluginSettings extends EventEmitter {\n    constructor(_userPluginSettings) {\n        super();\n        this._userPluginSettings = _userPluginSettings;\n        this._settings = {\n            disabled: false\n        };\n        Object.assign(this._settings, _userPluginSettings);\n    }\n    get(k) {\n        return this._settings[k];\n    }\n    set(k, v) {\n        const o = deepMerge({}, this._settings);\n        if (typeof k === 'string') {\n            if (this._settings[k] == v)\n                return;\n            this._settings[k] = v;\n        }\n        else if (isObject(k)) {\n            deepMerge(this._settings, k);\n        }\n        else {\n            return;\n        }\n        this.emit('change', Object.assign({}, this._settings), o);\n    }\n    toJSON() {\n        return this._settings;\n    }\n}\nclass PluginLogger extends EventEmitter {\n    constructor(_tag) {\n        super();\n        this._tag = _tag;\n        this._logs = [];\n    }\n    write(type, payload) {\n        let msg = payload.reduce((ac, it) => {\n            if (it && it instanceof Error) {\n                ac += `${it.message} ${it.stack}`;\n            }\n            else {\n                ac += it.toString();\n            }\n            return ac;\n        }, `[${this._tag}][${new Date().toLocaleTimeString()}] `);\n        this._logs.push([type, msg]);\n        this.emit('change');\n    }\n    clear() {\n        this._logs = [];\n        this.emit('change');\n    }\n    info(...args) {\n        this.write('INFO', args);\n    }\n    error(...args) {\n        this.write('ERROR', args);\n    }\n    warn(...args) {\n        this.write('WARN', args);\n    }\n    toJSON() {\n        return this._logs;\n    }\n}\nvar PluginLocalLoadStatus;\n(function (PluginLocalLoadStatus) {\n    PluginLocalLoadStatus[\"LOADING\"] = \"loading\";\n    PluginLocalLoadStatus[\"UNLOADING\"] = \"unloading\";\n    PluginLocalLoadStatus[\"LOADED\"] = \"loaded\";\n    PluginLocalLoadStatus[\"UNLOADED\"] = \"unload\";\n    PluginLocalLoadStatus[\"ERROR\"] = \"error\";\n})(PluginLocalLoadStatus || (PluginLocalLoadStatus = {}));\nfunction initUserSettingsHandlers(pluginLocal) {\n    const _ = (label) => `settings:${label}`;\n    pluginLocal.on(_('update'), (attrs) => {\n        if (!attrs)\n            return;\n        pluginLocal.settings?.set(attrs);\n    });\n}\nfunction initMainUIHandlers(pluginLocal) {\n    const _ = (label) => `main-ui:${label}`;\n    pluginLocal.on(_('visible'), ({ visible, toggle, cursor }) => {\n        const el = pluginLocal.getMainUI();\n        el?.classList[toggle ? 'toggle' : (visible ? 'add' : 'remove')]('visible');\n        // pluginLocal.caller!.callUserModel(LSPMSG, { type: _('visible'), payload: visible })\n        // auto focus frame\n        if (visible) {\n            if (!pluginLocal.shadow && el) {\n                el.contentWindow?.focus();\n            }\n        }\n        if (cursor) {\n            invokeHostExportedApi('restore_editing_cursor');\n        }\n    });\n    pluginLocal.on(_('attrs'), (attrs) => {\n        const el = pluginLocal.getMainUI();\n        Object.entries(attrs).forEach(([k, v]) => {\n            el?.setAttribute(k, v);\n        });\n    });\n    pluginLocal.on(_('style'), (style) => {\n        const el = pluginLocal.getMainUI();\n        Object.entries(style).forEach(([k, v]) => {\n            el.style[k] = v;\n        });\n    });\n}\nfunction initProviderHandlers(pluginLocal) {\n    let _ = (label) => `provider:${label}`;\n    let themed = false;\n    pluginLocal.on(_('theme'), (theme) => {\n        pluginLocal.themeMgr.registerTheme(pluginLocal.id, theme);\n        if (!themed) {\n            pluginLocal._dispose(() => {\n                pluginLocal.themeMgr.unregisterTheme(pluginLocal.id);\n            });\n            themed = true;\n        }\n    });\n    pluginLocal.on(_('style'), (style) => {\n        let key;\n        if (typeof style !== 'string') {\n            key = style.key;\n            style = style.style;\n        }\n        if (!style || !style.trim())\n            return;\n        pluginLocal._dispose(setupInjectedStyle(style, {\n            'data-injected-style': key ? `${key}-${pluginLocal.id}` : '',\n            'data-ref': pluginLocal.id\n        }));\n    });\n    pluginLocal.on(_('ui'), (ui) => {\n        pluginLocal._onHostMounted(() => {\n            // safe template\n            ui.template = DOMPurify.sanitize(ui.template);\n            pluginLocal._dispose(setupInjectedUI.call(pluginLocal, ui, {\n                'data-ref': pluginLocal.id\n            }));\n        });\n    });\n}\nfunction initApiProxyHandlers(pluginLocal) {\n    let _ = (label) => `api:${label}`;\n    pluginLocal.on(_('call'), async (payload) => {\n        let ret;\n        try {\n            ret = await invokeHostExportedApi(payload.method, ...payload.args);\n        }\n        catch (e) {\n            ret = {\n                [LSPMSG_ERROR_TAG]: e,\n            };\n        }\n        const { _sync } = payload;\n        if (pluginLocal.shadow) {\n            if (payload.actor) {\n                payload.actor.resolve(ret);\n            }\n            return;\n        }\n        if (_sync != null) {\n            const reply = (result) => {\n                pluginLocal.caller?.callUserModel(LSPMSG_SYNC, {\n                    result, _sync\n                });\n            };\n            Promise.resolve(ret).then(reply, reply);\n        }\n    });\n}\nclass IllegalPluginPackageError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = IllegalPluginPackageError.name;\n    }\n}\nclass ExistedImportedPluginPackageError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = ExistedImportedPluginPackageError.name;\n    }\n}\n/**\n * Host plugin for local\n */\nclass PluginLocal extends EventEmitter {\n    /**\n     * @param _options\n     * @param _themeMgr\n     * @param _ctx\n     */\n    constructor(_options, _themeMgr, _ctx) {\n        super();\n        this._options = _options;\n        this._themeMgr = _themeMgr;\n        this._ctx = _ctx;\n        this._disposes = [];\n        this._status = PluginLocalLoadStatus.UNLOADED;\n        this._id = _options.key || genID();\n        initUserSettingsHandlers(this);\n        initMainUIHandlers(this);\n        initProviderHandlers(this);\n        initApiProxyHandlers(this);\n    }\n    async _setupUserSettings() {\n        const { _options } = this;\n        const key = _options.name.replace(/[^a-z0-9]/gi, '_').toLowerCase() + '_' + this.id;\n        const logger = _options.logger = new PluginLogger('Loader');\n        try {\n            const [userSettingsFilePath, userSettings] = await invokeHostExportedApi('load_plugin_user_settings', key);\n            this._userSettingsFile = userSettingsFilePath;\n            const settings = _options.settings = new PluginSettings(userSettings);\n            // observe settings\n            settings.on('change', (a, b) => {\n                debug('linked settings change', a);\n                if (!a.disabled && b.disabled) {\n                    // Enable plugin\n                    this.load();\n                }\n                if (a.disabled && !b.disabled) {\n                    // Disable plugin\n                    this.unload();\n                }\n                if (a) {\n                    invokeHostExportedApi(`save_plugin_user_settings`, key, a);\n                }\n            });\n        }\n        catch (e) {\n            debug('[load plugin user settings Error]', e);\n            logger?.error(e);\n        }\n    }\n    getMainUI() {\n        if (this.shadow) {\n            return this.caller?._getSandboxShadowContainer();\n        }\n        return this.caller?._getSandboxIframeContainer();\n    }\n    async _preparePackageConfigs() {\n        const { url } = this._options;\n        let pkg;\n        try {\n            if (!url) {\n                throw new Error('Can not resolve package config location');\n            }\n            debug('prepare package root', url);\n            pkg = await invokeHostExportedApi('load_plugin_config', url);\n            if (!pkg || (pkg = JSON.parse(pkg), !pkg)) {\n                throw new Error(`Parse package config error #${url}/package.json`);\n            }\n        }\n        catch (e) {\n            throw new IllegalPluginPackageError(e.message);\n        }\n        // Pick legal attrs\n        ['name', 'author', 'repository', 'version', 'description'].forEach(k => {\n            this._options[k] = pkg[k];\n        });\n        // TODO: How with local protocol\n        const localRoot = this._localRoot = url;\n        const logseq = pkg.logseq || {};\n        const makeFullUrl = (loc, useFileProtocol = false) => {\n            if (!loc)\n                return;\n            const reg = /^(http|file|assets)/;\n            if (!reg.test(loc)) {\n                const url = path.join(localRoot, loc);\n                loc = reg.test(url) ? url : ('file://' + url);\n            }\n            return useFileProtocol ? loc : loc.replace('file:', 'assets:');\n        };\n        const validateMain = (main) => main && /\\.(js|html)$/.test(main);\n        // Entry from main\n        if (validateMain(pkg.main)) {\n            this._options.entry = makeFullUrl(pkg.main, true);\n            if (logseq.mode) {\n                this._options.mode = logseq.mode;\n            }\n        }\n        const icon = logseq.icon || pkg.icon;\n        if (icon) {\n            this._options.icon = makeFullUrl(icon);\n        }\n        // TODO: strategy for Logseq plugins center\n        if (logseq.id) {\n            this._id = logseq.id;\n        }\n        else {\n            logseq.id = this.id;\n            try {\n                await invokeHostExportedApi('save_plugin_config', url, { ...pkg, logseq });\n            }\n            catch (e) {\n                debug('[save plugin ID Error] ', e);\n            }\n        }\n        // Validate id\n        const { registeredPlugins, isRegistering } = this._ctx;\n        if (isRegistering && registeredPlugins.has(logseq.id)) {\n            throw new ExistedImportedPluginPackageError('prepare package Error');\n        }\n        return async () => {\n            try {\n                // 0. Install Themes\n                let themes = logseq.themes;\n                if (themes) {\n                    await this._loadConfigThemes(Array.isArray(themes) ? themes : [themes]);\n                }\n            }\n            catch (e) {\n                debug('[prepare package effect Error]', e);\n            }\n        };\n    }\n    async _tryToNormalizeEntry() {\n        let { entry, settings } = this.options;\n        let devEntry = settings?.get('_devEntry');\n        if (devEntry) {\n            this._options.entry = devEntry;\n            return;\n        }\n        if (!entry.endsWith('.js'))\n            return;\n        let sdkPath = await invokeHostExportedApi('_callApplication', 'getAppPath');\n        let entryPath = await invokeHostExportedApi('write_user_tmp_file', `${this._id}_index.html`, `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\">\n    <title>logseq plugin entry</title>\n    <script src=\"${sdkPath}/js/lsplugin.user.js\"></script>\n  </head>\n  <body>\n  <div id=\"app\"></div>\n  <script src=\"${entry}\"></script>\n  </body>\n</html>`);\n        this._options.entry = withFileProtocol(entryPath);\n    }\n    async _loadConfigThemes(themes) {\n        themes.forEach((options) => {\n            if (!options.url)\n                return;\n            if (!options.url.startsWith('http') && this._localRoot) {\n                options.url = path.join(this._localRoot, options.url);\n                // file:// for native\n                if (!options.url.startsWith('file:')) {\n                    options.url = 'assets://' + options.url;\n                }\n            }\n            // @ts-ignore\n            this.emit('provider:theme', options);\n        });\n    }\n    async load(readyIndicator) {\n        if (this.pending) {\n            return;\n        }\n        this._status = PluginLocalLoadStatus.LOADING;\n        this._loadErr = undefined;\n        try {\n            let installPackageThemes = () => Promise.resolve();\n            if (!this.options.entry) { // Themes package no entry field\n                installPackageThemes = await this._preparePackageConfigs();\n            }\n            if (!this.settings) {\n                await this._setupUserSettings();\n            }\n            if (!this.disabled) {\n                await installPackageThemes.call(null);\n            }\n            if (this.disabled || !this.options.entry) {\n                return;\n            }\n            await this._tryToNormalizeEntry();\n            this._caller = new LSPluginCaller(this);\n            await this._caller.connectToChild();\n            const readyFn = () => {\n                this._caller?.callUserModel(LSPMSG_READY);\n            };\n            if (readyIndicator) {\n                readyIndicator.promise.then(readyFn);\n            }\n            else {\n                readyFn();\n            }\n            this._disposes.push(async () => {\n                await this._caller?.destroy();\n            });\n        }\n        catch (e) {\n            debug('[Load Plugin Error] ', e);\n            this.logger?.error(e);\n            this._status = PluginLocalLoadStatus.ERROR;\n            this._loadErr = e;\n        }\n        finally {\n            if (!this._loadErr) {\n                this._status = PluginLocalLoadStatus.LOADED;\n            }\n        }\n    }\n    async reload() {\n        debug('TODO: reload plugin', this.id);\n    }\n    /**\n     * @param unregister If true delete plugin files\n     */\n    async unload(unregister = false) {\n        if (this.pending) {\n            return;\n        }\n        if (unregister) {\n            await this.unload();\n            if (this.isInstalledInUserRoot) {\n                debug('TODO: remove plugin local files from user home root :)');\n            }\n            return;\n        }\n        try {\n            this._status = PluginLocalLoadStatus.UNLOADING;\n            const eventBeforeUnload = { unregister };\n            // sync call\n            try {\n                await this._caller?.callUserModel(AWAIT_LSPMSGFn(LSPMSG_BEFORE_UNLOAD), eventBeforeUnload);\n                this.emit('beforeunload', eventBeforeUnload);\n            }\n            catch (e) {\n                console.error('[beforeunload Error]', e);\n            }\n            await this.dispose();\n            this.emit('unloaded');\n        }\n        catch (e) {\n            debug('[plugin unload Error]', e);\n        }\n        finally {\n            this._status = PluginLocalLoadStatus.UNLOADED;\n        }\n    }\n    async dispose() {\n        for (const fn of this._disposes) {\n            try {\n                fn && (await fn());\n            }\n            catch (e) {\n                console.error(this.debugTag, 'dispose Error', e);\n            }\n        }\n        // clear\n        this._disposes = [];\n    }\n    _dispose(fn) {\n        if (!fn)\n            return;\n        this._disposes.push(fn);\n    }\n    _onHostMounted(callback) {\n        const actor = this._ctx.hostMountedActor;\n        if (!actor || actor.settled) {\n            callback();\n        }\n        else {\n            actor?.promise.then(callback);\n        }\n    }\n    get isInstalledInUserRoot() {\n        const userRoot = this._ctx.options.localUserConfigRoot;\n        const plugRoot = this._localRoot;\n        return userRoot && plugRoot && plugRoot.startsWith(userRoot);\n    }\n    get loaded() {\n        return this._status === PluginLocalLoadStatus.LOADED;\n    }\n    get pending() {\n        return [PluginLocalLoadStatus.LOADING, PluginLocalLoadStatus.UNLOADING]\n            .includes(this._status);\n    }\n    get status() {\n        return this._status;\n    }\n    get settings() {\n        return this.options.settings;\n    }\n    get logger() {\n        return this.options.logger;\n    }\n    get disabled() {\n        return this.settings?.get('disabled');\n    }\n    get caller() {\n        return this._caller;\n    }\n    get id() {\n        return this._id;\n    }\n    get shadow() {\n        return this.options.mode === 'shadow';\n    }\n    get options() {\n        return this._options;\n    }\n    get themeMgr() {\n        return this._themeMgr;\n    }\n    get debugTag() {\n        const name = this._options?.name;\n        return `#${this._id} ${name ?? ''}`;\n    }\n    get localRoot() {\n        return this._localRoot || this._options.url;\n    }\n    get loadErr() {\n        return this._loadErr;\n    }\n    get userSettingsFile() {\n        return this._userSettingsFile;\n    }\n    toJSON() {\n        const json = { ...this.options };\n        json.id = this.id;\n        json.err = this.loadErr;\n        json.usf = this.userSettingsFile;\n        return json;\n    }\n}\n/**\n * Host plugin core\n */\nclass LSPluginCore extends EventEmitter {\n    /**\n     * @param _options\n     */\n    constructor(_options) {\n        super();\n        this._options = _options;\n        this._isRegistering = false;\n        this._hostMountedActor = deferred();\n        this._userPreferences = {};\n        this._registeredThemes = new Map();\n        this._registeredPlugins = new Map();\n    }\n    async loadUserPreferences() {\n        try {\n            const settings = await invokeHostExportedApi(`load_user_preferences`);\n            if (settings) {\n                Object.assign(this._userPreferences, settings);\n            }\n        }\n        catch (e) {\n            debug('[load user preferences Error]', e);\n        }\n    }\n    async saveUserPreferences(settings) {\n        try {\n            if (settings) {\n                Object.assign(this._userPreferences, settings);\n            }\n            await invokeHostExportedApi(`save_user_preferences`, this._userPreferences);\n        }\n        catch (e) {\n            debug('[save user preferences Error]', e);\n        }\n    }\n    async activateUserPreferences() {\n        const { theme } = this._userPreferences;\n        // 0. theme\n        if (theme) {\n            await this.selectTheme(theme, false);\n        }\n    }\n    /**\n     * @param plugins\n     * @param initial\n     */\n    async register(plugins, initial = false) {\n        if (!Array.isArray(plugins)) {\n            await this.register([plugins]);\n            return;\n        }\n        try {\n            this._isRegistering = true;\n            const userConfigRoot = this._options.localUserConfigRoot;\n            const readyIndicator = this._readyIndicator = deferred();\n            await this.loadUserPreferences();\n            const externals = new Set(this._userPreferences.externals || []);\n            if (initial) {\n                plugins = plugins.concat([...externals].filter(url => {\n                    return !plugins.length || plugins.every((p) => !p.entry && (p.url !== url));\n                }).map(url => ({ url })));\n            }\n            for (const pluginOptions of plugins) {\n                const { url } = pluginOptions;\n                const pluginLocal = new PluginLocal(pluginOptions, this, this);\n                const timeLabel = `[LOAD Plugin] ${pluginLocal.debugTag}`;\n                console.time(timeLabel);\n                await pluginLocal.load(readyIndicator);\n                const { loadErr } = pluginLocal;\n                if (loadErr) {\n                    debug(`[Failed LOAD Plugin] #`, pluginOptions);\n                    this.emit('error', loadErr);\n                    if (loadErr instanceof IllegalPluginPackageError ||\n                        loadErr instanceof ExistedImportedPluginPackageError) {\n                        // TODO: notify global log system?\n                        continue;\n                    }\n                }\n                console.timeEnd(timeLabel);\n                pluginLocal.settings?.on('change', (a) => {\n                    this.emit('settings-changed', pluginLocal.id, a);\n                    pluginLocal.caller?.callUserModel(LSPMSG_SETTINGS, { payload: a });\n                });\n                this._registeredPlugins.set(pluginLocal.id, pluginLocal);\n                this.emit('registered', pluginLocal);\n                // external plugins\n                if (!pluginLocal.isInstalledInUserRoot) {\n                    externals.add(url);\n                }\n            }\n            await this.saveUserPreferences({ externals: Array.from(externals) });\n            await this.activateUserPreferences();\n            readyIndicator.resolve('ready');\n        }\n        catch (e) {\n            console.error(e);\n        }\n        finally {\n            this._isRegistering = false;\n        }\n    }\n    async reload(plugins) {\n        if (!Array.isArray(plugins)) {\n            await this.reload([plugins]);\n            return;\n        }\n        for (const identity of plugins) {\n            const p = this.ensurePlugin(identity);\n            await p.reload();\n        }\n    }\n    async unregister(plugins) {\n        if (!Array.isArray(plugins)) {\n            await this.unregister([plugins]);\n            return;\n        }\n        const unregisteredExternals = [];\n        for (const identity of plugins) {\n            const p = this.ensurePlugin(identity);\n            if (!p.isInstalledInUserRoot) {\n                unregisteredExternals.push(p.options.url);\n            }\n            await p.unload(true);\n            this._registeredPlugins.delete(identity);\n            this.emit('unregistered', identity);\n        }\n        let externals = this._userPreferences.externals || [];\n        if (externals.length && unregisteredExternals.length) {\n            await this.saveUserPreferences({\n                externals: externals.filter((it) => {\n                    return !unregisteredExternals.includes(it);\n                })\n            });\n        }\n    }\n    async enable(plugin) {\n        const p = this.ensurePlugin(plugin);\n        if (p.pending)\n            return;\n        this.emit('beforeenable');\n        p.settings?.set('disabled', false);\n        // this.emit('enabled', p)\n    }\n    async disable(plugin) {\n        const p = this.ensurePlugin(plugin);\n        if (p.pending)\n            return;\n        this.emit('beforedisable');\n        p.settings?.set('disabled', true);\n        // this.emit('disabled', p)\n    }\n    async _hook(ns, type, payload, pid) {\n        for (const [_, p] of this._registeredPlugins) {\n            if (!pid || pid === p.id) {\n                p.caller?.callUserModel(LSPMSG, {\n                    ns, type: snakeCase(type), payload\n                });\n            }\n        }\n    }\n    hookApp(type, payload, pid) {\n        this._hook(`hook:app`, type, payload, pid);\n    }\n    hookEditor(type, payload, pid) {\n        this._hook(`hook:editor`, type, payload, pid);\n    }\n    _execDirective(tag, ...params) {\n    }\n    ensurePlugin(plugin) {\n        if (plugin instanceof PluginLocal) {\n            return plugin;\n        }\n        const p = this._registeredPlugins.get(plugin);\n        if (!p) {\n            throw new Error(`plugin #${plugin} not existed.`);\n        }\n        return p;\n    }\n    hostMounted() {\n        this._hostMountedActor.resolve();\n    }\n    get registeredPlugins() {\n        return this._registeredPlugins;\n    }\n    get options() {\n        return this._options;\n    }\n    get readyIndicator() {\n        return this._readyIndicator;\n    }\n    get hostMountedActor() {\n        return this._hostMountedActor;\n    }\n    get isRegistering() {\n        return this._isRegistering;\n    }\n    get themes() {\n        return this._registeredThemes;\n    }\n    async registerTheme(id, opt) {\n        debug('registered Theme #', id, opt);\n        if (!id)\n            return;\n        let themes = this._registeredThemes.get(id);\n        if (!themes) {\n            this._registeredThemes.set(id, themes = []);\n        }\n        themes.push(opt);\n        this.emit('theme-changed', this.themes, { id, ...opt });\n    }\n    async selectTheme(opt, effect = true) {\n        setupInjectedTheme(opt?.url);\n        this.emit('theme-selected', opt);\n        effect && this.saveUserPreferences({ theme: opt });\n    }\n    async unregisterTheme(id) {\n        debug('unregistered Theme #', id);\n        if (!this._registeredThemes.has(id))\n            return;\n        this._registeredThemes.delete(id);\n        this.emit('theme-changed', this.themes, { id });\n    }\n}\nfunction setupPluginCore(options) {\n    const pluginCore = new LSPluginCore(options);\n    debug('=== 🔗 Setup Logseq Plugin System 🔗 ===');\n    window.LSPluginCore = pluginCore;\n}\nexport { PluginLocal, setupPluginCore };\n"],"sourceRoot":""}
\ No newline at end of file
diff --git a/resources/js/lsplugin.core.js.LICENSE.txt b/resources/js/lsplugin.core.js.LICENSE.txt
new file mode 100644
index 0000000000..9e64a2294c
--- /dev/null
+++ b/resources/js/lsplugin.core.js.LICENSE.txt
@@ -0,0 +1 @@
+/*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */
diff --git a/resources/js/preload.js b/resources/js/preload.js
index bed63f3f5f..329e00cda2 100644
--- a/resources/js/preload.js
+++ b/resources/js/preload.js
@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const { ipcRenderer, contextBridge, shell, clipboard } = require('electron')
+const { ipcRenderer, contextBridge, shell, clipboard, webFrame } = require('electron')
 
 const IS_MAC = process.platform === 'darwin'
 const IS_WIN32 = process.platform === 'win32'
@@ -136,4 +136,10 @@ contextBridge.exposeInMainWorld('apis', {
 
   getFilePathFromClipboard,
   isClipboardHasImage,
+
+  setZoomFactor (factor) {
+    webFrame.setZoomFactor(factor)
+  },
+
+  isAbsolutePath: path.isAbsolute.bind(path)
 })
diff --git a/resources/package.json b/resources/package.json
index 0bfc5790f2..a28125a229 100644
--- a/resources/package.json
+++ b/resources/package.json
@@ -10,7 +10,7 @@
     "electron:debug": "electron-forge start --inspect-electron",
     "electron:make": "electron-forge make",
     "electron:publish:github": "electron-forge publish",
-    "rebuild:better-sqlite3": "electron-rebuild -v 12 -f -w better-sqlite3",
+    "rebuild:better-sqlite3": "electron-rebuild -v 13 -f -w better-sqlite3",
     "postinstall": "install-app-deps"
   },
   "config": {
diff --git a/src/electron/electron/handler.cljs b/src/electron/electron/handler.cljs
index 6dd5e5f299..2183e164db 100644
--- a/src/electron/electron/handler.cljs
+++ b/src/electron/electron/handler.cljs
@@ -73,6 +73,25 @@
                 (remove nil?))]
     (vec (cons {:path (utils/fix-win-path! path)} result))))
 
+(defn- get-ls-dotdir-root
+  []
+  (let [lg-dir (str (.getPath app "home") "/.logseq")]
+    (if-not (fs/existsSync lg-dir)
+      (and (fs/mkdirSync lg-dir) lg-dir)
+      lg-dir)))
+
+(defn- get-ls-default-plugins
+  []
+  (let [plugins-root (path/join (get-ls-dotdir-root) "plugins")
+        _ (if-not (fs/existsSync plugins-root)
+            (fs/mkdirSync plugins-root))
+        dirs (js->clj (fs/readdirSync plugins-root #js{"withFileTypes" true}))
+        dirs (->> dirs
+                  (filter #(.isDirectory %))
+                  (filter #(not (string/starts-with? (.-name %) "_")))
+                  (map #(path/join plugins-root (.-name %))))]
+    dirs))
+
 (defmethod handle :openDir [^js window _messages]
   (let [result (.showOpenDialogSync dialog (bean/->js
                                             {:properties ["openDirectory" "createDirectory" "promptToCreate"]}))
@@ -130,6 +149,25 @@
   (when dir
     (watcher/watch-dir! window dir)))
 
+(defmethod handle :openDialogSync [^js window _messages]
+  (let [result (.showOpenDialogSync dialog (bean/->js
+                                             {:properties ["openDirectory"]}))
+        path (first result)]
+    path))
+
+(defmethod handle :getLogseqDotDirRoot []
+  (get-ls-dotdir-root))
+
+(defmethod handle :getUserDefaultPlugins []
+  (get-ls-default-plugins))
+
+(defmethod handle :relaunchApp []
+  (.relaunch app) (.quit app))
+
+(defmethod handle :quitApp []
+  (.quit app))
+
+
 (defmethod handle :default [args]
   (println "Error: no ipc handler for: " (bean/->js args)))
 
diff --git a/src/main/frontend/commands.cljs b/src/main/frontend/commands.cljs
index 1936233d69..64c166a73f 100644
--- a/src/main/frontend/commands.cljs
+++ b/src/main/frontend/commands.cljs
@@ -13,6 +13,7 @@
             [goog.object :as gobj]
             [frontend.format :as format]
             [frontend.handler.common :as common-handler]
+            [frontend.handler.plugin :as plugin-handler]
             [frontend.handler.draw :as draw]
             [frontend.handler.notification :as notification]
             [promesa.core :as p]))
@@ -175,10 +176,11 @@
 
      ;; TODO:
      ;; ["Upload a file" nil]
-     ]
+]
     (markdown-headings)
     ;; Allow user to modify or extend, should specify how to extend.
-    (state/get-commands))
+    (state/get-commands)
+    (state/get-plugins-commands))
    (remove nil?)
    (util/distinct-by-last-wins first)))
 
@@ -404,6 +406,9 @@
 
 (defmulti handle-step first)
 
+(defmethod handle-step :editor/hook [[_ event {:keys [pid] :as payload}] format]
+  (plugin-handler/hook-plugin-editor event (merge payload {:format format :uuid (:block/uuid (state/get-edit-block))}) pid))
+
 (defmethod handle-step :editor/input [[_ value option]]
   (when-let [input-id (state/get-edit-input-id)]
     (insert! input-id value option)))
@@ -423,13 +428,18 @@
     (when-let [current-input (gdom/getElement input-id)]
       (cursor/move-cursor-to-end current-input))))
 
-(defmethod handle-step :editor/clear-current-slash [[_]]
+(defmethod handle-step :editor/restore-saved-cursor [[_]]
+  (when-let [input-id (state/get-edit-input-id)]
+    (when-let [current-input (gdom/getElement input-id)]
+      (cursor/move-cursor-to current-input (:editor/last-saved-cursor @state/state)))))
+
+(defmethod handle-step :editor/clear-current-slash [[_ space?]]
   (when-let [input-id (state/get-edit-input-id)]
     (when-let [current-input (gdom/getElement input-id)]
       (let [edit-content (gobj/get current-input "value")
             current-pos (cursor/pos current-input)
             prefix (subs edit-content 0 current-pos)
-            prefix (util/replace-last slash prefix "")
+            prefix (util/replace-last slash prefix "" (boolean space?))
             new-value (str prefix
                            (subs edit-content current-pos))]
         (state/set-block-content-and-last-pos! input-id
diff --git a/src/main/frontend/components/header.cljs b/src/main/frontend/components/header.cljs
index 01517e8d3a..b74fd0e73b 100644
--- a/src/main/frontend/components/header.cljs
+++ b/src/main/frontend/components/header.cljs
@@ -15,6 +15,7 @@
             [frontend.components.repo :as repo]
             [frontend.components.search :as search]
             [frontend.components.export :as export]
+            [frontend.components.plugins :as plugins]
             [frontend.components.right-sidebar :as sidebar]
             [frontend.handler.page :as page-handler]
             [frontend.handler.web.nfs :as nfs]
@@ -72,6 +73,7 @@
 (rum/defc dropdown-menu < rum/reactive
   [{:keys [me current-repo t default-home]}]
   (let [projects (state/sub [:me :projects])
+        developer-mode? (state/sub [:ui/developer-mode?])
         logged? (state/logged?)]
     (ui/dropdown-with-links
      (fn [{:keys [toggle-fn]}]
@@ -107,6 +109,14 @@
         :options {:on-click #(ui-handler/toggle-settings-modal!)}
         :icon svg/settings-sm}
 
+       (when developer-mode?
+         {:title (t :plugins)
+          :options {:href (rfe/href :plugins)}})
+
+       (when developer-mode?
+         {:title (t :themes)
+          :options {:on-click #(plugins/open-select-theme!)}})
+
        (when current-repo
          {:title (t :export)
           :options {:on-click #(state/set-modal! export/export)}
@@ -149,8 +159,7 @@
        {:on-double-click (fn [^js e]
                            (when-let [target (.-target e)]
                              (when (and (util/electron?)
-                                        (or (.. target -classList (contains "cp__header"))
-                                            (. target (closest "#search"))))
+                                        (or (.. target -classList (contains "cp__header"))))
                                (js/window.apis.toggleMaxOrMinActiveWindow))))}
        (left-menu-button {:on-click (fn []
                                       (open-fn)
diff --git a/src/main/frontend/components/page.cljs b/src/main/frontend/components/page.cljs
index 5f00014662..e1be084993 100644
--- a/src/main/frontend/components/page.cljs
+++ b/src/main/frontend/components/page.cljs
@@ -15,6 +15,7 @@
             [clojure.string :as string]
             [frontend.components.block :as block]
             [frontend.components.editor :as editor]
+            [frontend.components.plugins :as plugins]
             [frontend.components.reference :as reference]
             [frontend.components.svg :as svg]
             [frontend.components.export :as export]
@@ -366,6 +367,7 @@
                                     (flatten)
                                     (remove nil?)))]
                    [:div.flex.flex-row
+                    (plugins/hook-ui-slot :page-head-actions-slotted nil)
                     [:a.opacity-30.hover:opacity-100.page-op.mr-1
                      {:title "Search in current page"
                       :on-click #(route-handler/go-to-search! :page)}
diff --git a/src/main/frontend/components/plugins.cljs b/src/main/frontend/components/plugins.cljs
new file mode 100644
index 0000000000..e89edd6d14
--- /dev/null
+++ b/src/main/frontend/components/plugins.cljs
@@ -0,0 +1,170 @@
+(ns frontend.components.plugins
+  (:require [rum.core :as rum]
+            [frontend.state :as state]
+            [cljs-bean.core :as bean]
+            [frontend.ui :as ui]
+            [frontend.util :as util]
+            [electron.ipc :as ipc]
+            [promesa.core :as p]
+            [frontend.components.svg :as svg]
+            [frontend.handler.notification :as notification]
+            [frontend.handler.plugin :as plugin-handler]
+            [clojure.string :as string]))
+
+(rum/defc installed-themes
+  < rum/reactive
+  []
+  (let [themes (state/sub :plugin/installed-themes)
+        selected (state/sub :plugin/selected-theme)
+        themes (cons {:name "Default Theme" :url nil :description "Logseq default light/dark theme."} themes)]
+
+    [:div.cp__themes-installed
+     [:h2.mb-4.text-xl "Installed Themes"]
+     (for [opt themes]
+       (let [current-selected (= selected (:url opt))]
+         [:div.it.flex.px-3.py-2.mb-2.rounded-sm.justify-between
+          {:key   (:url opt)
+           :class [(if current-selected "is-selected")]
+           :on-click #(do (js/LSPluginCore.selectTheme (if current-selected nil (clj->js opt)))
+                          (state/set-modal! nil))}
+          [:section
+           [:strong.block (:name opt)]
+           [:small.opacity-30 (:description opt)]]
+          [:small.flex-shrink-0.flex.items-center.opacity-10
+           (if current-selected "current")]]))]))
+
+(rum/defc unpacked-plugin-loader
+  [unpacked-pkg-path]
+  (rum/use-effect!
+   (fn []
+     (let [err-handle
+           (fn [^js e]
+             (case (keyword (aget e "name"))
+               :IllegalPluginPackageError
+               (notification/show! "Illegal Logseq plugin package." :error)
+               :ExistedImportedPluginPackageError
+               (notification/show! "Existed Imported plugin package." :error)
+               :default)
+             (plugin-handler/reset-unpacked-state))
+           reg-handle #(plugin-handler/reset-unpacked-state)]
+       (when unpacked-pkg-path
+         (doto js/LSPluginCore
+           (.once "error" err-handle)
+           (.once "registered" reg-handle)
+           (.register (bean/->js {:url unpacked-pkg-path}))))
+       #(doto js/LSPluginCore
+          (.off "error" err-handle)
+          (.off "registered" reg-handle))))
+   [unpacked-pkg-path])
+
+  (when unpacked-pkg-path
+    [:strong.inline-flex.px-3 "Loading ..."]))
+
+(rum/defc simple-markdown-display
+  < rum/reactive
+  []
+  (let [[content item] (state/sub :plugin/active-readme)]
+    [:div.cp__plugins-details
+     {:on-click (fn [^js/MouseEvent e]
+                  (when-let [target (.-target e)]
+                    (when (and (= (string/lower-case (.-nodeName target)) "a")
+                               (not (string/blank? (. target getAttribute "href"))))
+                      (js/apis.openExternal (. target getAttribute "href"))
+                      (.preventDefault e))))}
+     (when-let [repo (:repository item)]
+       (when-let [repo (if (string? repo) repo (:url repo))]
+         [:div.p-4.rounded-md.bg-base-3
+          [:strong [:a.flex.items-center {:target "_blank" :href repo} [:span.mr-1 (svg/github {:width 25 :height 25})] repo]]]))
+     [:div.p-1.bg-transparent.border-none.ls-block
+      {:style                   {:min-height "60vw"}
+       :dangerouslySetInnerHTML {:__html content}}]]))
+
+(rum/defc plugin-item-card
+  [{:keys [id name settings version url description author icon usf] :as item}]
+  (let [disabled (:disabled settings)]
+    [:div.cp__plugins-item-card
+     [:div.l.link-block
+      {:on-click #(plugin-handler/open-readme! url item simple-markdown-display)}
+      (if icon
+        [:img.icon {:src icon}]
+        svg/folder)]
+     [:div.r
+      [:h3.head.text-xl.font-bold.pt-1.5
+       {:on-click #(plugin-handler/open-readme! url item simple-markdown-display)}
+       [:span name]
+       [:sup.inline-block.px-1.text-xs.opacity-30 version]]
+      [:div.desc.text-xs.opacity-60
+       [:p description]
+       ;;[:small (js/JSON.stringify (bean/->js settings))]
+]
+      [:div.flag
+       [:p.text-xs.text-gray-300.pr-2.flex.justify-between.dark:opacity-40
+        [:small author]
+        [:small (str "ID: " id)]]]
+
+      [:div.ctl
+       [:div.l
+        [:div.de
+         [:strong svg/settings-sm]
+         [:ul.menu-list
+          [:li {:on-click #(if usf (js/apis.openPath usf))} "Open settings"]
+          [:li {:on-click #(js/apis.openPath url)} "Open plugin package"]
+          [:li {:on-click
+                #(let [confirm-fn
+                       (ui/make-confirm-modal
+                        {:title      (str "Are you sure uninstall plugin [" name "] ?")
+                         :on-confirm (fn [_ {:keys [close-fn]}]
+                                       (close-fn)
+                                       (plugin-handler/unregister-plugin id))})]
+                   (state/set-modal! confirm-fn))}
+           "Uninstall plugin"]]]]
+
+       [:div.flex.items-center
+        [:small.de (if disabled "Disabled" "Enabled")]
+        (ui/toggle (not disabled)
+                   (fn []
+                     (js-invoke js/LSPluginCore (if disabled "enable" "disable") id))
+                   true)]]]]))
+
+(rum/defc installed-page
+  < rum/reactive
+  []
+  (let [installed-plugins (state/sub :plugin/installed-plugins)
+        selected-unpacked-pkg (state/sub :plugin/selected-unpacked-pkg)]
+    [:div.cp__plugins-page-installed
+     [:h1 "Installed Plugins"]
+     [:div.mb-6.flex.items-center.justify-between
+      (ui/button
+       "Load unpacked plugin"
+       :intent "logseq"
+       :on-click plugin-handler/load-unpacked-plugin)
+      (unpacked-plugin-loader selected-unpacked-pkg)
+      (when (util/electron?)
+        (ui/button
+         [:span.flex.items-center
+           ;;svg/settings-sm
+          "Open plugin preferences file"]
+         :intent "logseq"
+         :on-click (fn []
+                     (p/let [root (plugin-handler/get-ls-dotdir-root)]
+                       (js/apis.openPath (str root "/preferences.json"))))))]
+
+     [:div.cp__plugins-item-lists.grid-cols-1.md:grid-cols-2.lg:grid-cols-3
+      (for [[_ item] installed-plugins]
+        (rum/with-key (plugin-item-card item) (:id item)))]]))
+
+(defn open-select-theme!
+  []
+  (state/set-modal! installed-themes))
+
+(rum/defc hook-ui-slot
+  ([type payload] (hook-ui-slot type payload nil))
+  ([type payload opts]
+   (let [id (str "slot__" (util/rand-str 8))]
+     (rum/use-effect!
+      (fn []
+        (plugin-handler/hook-plugin-app type {:slot id :payload payload} nil)
+        #())
+      [])
+     [:div.lsp-hook-ui-slot
+      (merge opts {:id id})])))
\ No newline at end of file
diff --git a/src/main/frontend/components/plugins.css b/src/main/frontend/components/plugins.css
new file mode 100644
index 0000000000..24556b216e
--- /dev/null
+++ b/src/main/frontend/components/plugins.css
@@ -0,0 +1,189 @@
+.cp__plugins {
+  &-page-installed {
+    min-height: 60vh;
+    padding-top: 20px;
+
+    > h1 {
+      padding: 20px 0;
+      font-size: 38px;
+    }
+  }
+
+  &-item-lists {
+    @apply w-full grid grid-flow-row gap-3 pt-1;
+  }
+
+  &-item-card {
+    @apply flex py-3 px-1 rounded-md;
+
+    background-color: var(--ls-secondary-background-color);
+    height: 180px;
+
+    svg, .icon {
+      width: 70px;
+      height: 70px;
+      opacity: .8;
+
+      &:hover {
+        opacity: 1;
+      }
+    }
+
+    .head {
+      max-height: 60px;
+      overflow: hidden;
+
+      cursor: pointer;
+
+      &:active {
+        opacity: .8;
+      }
+    }
+
+    .desc {
+      height: 60px;
+      overflow: hidden;
+    }
+
+    .flag {
+      position: absolute;
+      bottom: 20px;
+      left: 0;
+      width: 100%;
+    }
+
+    > .l {
+      padding: 8px;
+    }
+
+    > .r {
+      flex: 1;
+      position: relative;
+
+      p {
+        @apply py-1 m-0;
+      }
+
+      .ctl {
+        @apply flex pl-2 items-center justify-between absolute w-full;
+
+        bottom: -8px;
+        right: 8px;
+
+        .de {
+          font-size: 10px;
+          padding: 5px 0;
+          padding-right: 10px;
+          border-radius: 2px;
+          user-select: none;
+          transition: none;
+          opacity: .2;
+          position: relative;
+          z-index: var(--ls-z-index-level-1);
+
+          .menu-list {
+            @apply shadow-md rounded-sm absolute hidden list-none overflow-hidden m-0 p-0;
+
+            background-color: var(--ls-primary-background-color);
+            top: 20px;
+            left: 0;
+            min-width: 120px;
+
+            > li {
+              margin: 0;
+              padding: 5px;
+              transition: background-color .2s;
+              user-select: none;
+              font-weight: bold;
+              opacity: .9;
+
+              &:hover {
+                background-color: var(--ls-quaternary-background-color);
+
+                &:active {
+                  opacity: 1;
+                }
+              }
+            }
+          }
+
+          &.err {
+            @apply text-red-500 opacity-100;
+          }
+
+          &.log {
+            padding: 5px;
+          }
+
+          svg {
+            width: 13px;
+            height: 13px;
+          }
+        }
+
+        > .l {
+          @apply flex items-center;
+
+          margin-left: -80px;
+
+          .de {
+            &:hover {
+              opacity: .9;
+
+              .menu-list {
+                display: block;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  &-details {}
+}
+
+.cp__themes {
+  &-installed {
+    min-width: 480px;
+
+    > .it {
+      user-select: none;
+      cursor: pointer;
+      background-color: var(--ls-secondary-background-color);
+      border: 1px solid transparent;
+      transition: background-color .3s;
+
+      &:hover, &.is-selected {
+        background-color: var(--ls-quaternary-background-color);
+      }
+    }
+  }
+}
+
+.lsp-iframe-sandbox, .lsp-shadow-sandbox {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: -1;
+  visibility: hidden;
+  height: 0;
+  width: 0;
+  padding: 0;
+  margin: 0;
+
+  &.visible {
+    z-index: 1;
+    width: 100%;
+    height: 100%;
+    visibility: visible;
+  }
+}
+
+body {
+  &[data-page=page] {
+    .lsp-hook-ui-slot {
+      @apply flex px-1 opacity-30 hover:opacity-50;
+    }
+  }
+}
diff --git a/src/main/frontend/components/settings.cljs b/src/main/frontend/components/settings.cljs
index 49465dcd9f..1ad413ded6 100644
--- a/src/main/frontend/components/settings.cljs
+++ b/src/main/frontend/components/settings.cljs
@@ -271,7 +271,7 @@
                               (route-handler/redirect! {:to :repos}))))}
             (for [format (sort (date/journal-title-formatters))]
               [:option (cond->
-                           {:key format}
+                        {:key format}
                          (= format custom-date-format)
                          (assoc :selected "selected"))
                format])]]]]
@@ -416,7 +416,10 @@
          [:div.mt-1.sm:mt-0.sm:col-span-2
           [:div.rounded-md.sm:max-w-xs
            (ui/toggle developer-mode?
-                      #(state/set-developer-mode! (not developer-mode?))
+                      (fn []
+                        (let [mode (not developer-mode?)]
+                          (state/set-developer-mode! mode)
+                          (and mode (js/alert (t :developer-mode-alert)))))
                       true)]]]
         [:div.text-sm.opacity-50
          (t :settings-page/developer-mode-desc)]
diff --git a/src/main/frontend/components/sidebar.cljs b/src/main/frontend/components/sidebar.cljs
index 84454b3cc5..e3273e331a 100644
--- a/src/main/frontend/components/sidebar.cljs
+++ b/src/main/frontend/components/sidebar.cljs
@@ -304,8 +304,10 @@
       (theme/container
        {:theme         theme
         :route         route-match
+        :current-repo  current-repo
         :nfs-granted?  granted?
         :db-restoring? db-restoring?
+        :sidebar-open? sidebar-open?
         :system-theme? system-theme?
         :on-click      #(do
                           (editor-handler/unhighlight-blocks!)
diff --git a/src/main/frontend/components/svg.cljs b/src/main/frontend/components/svg.cljs
index b8251eca59..9f1afde239 100644
--- a/src/main/frontend/components/svg.cljs
+++ b/src/main/frontend/components/svg.cljs
@@ -538,3 +538,15 @@
      :stroke-width "2",
      :stroke-linejoin "round",
      :stroke-linecap "round"}]])
+
+
+(defn github
+  ([] (github nil))
+  ([opts]
+   [:svg.icon
+    (merge {:stroke  "currentColor"
+            :fill    "currentColor"
+            :viewBox "0 0 1024 1024"
+            :width   "20"
+            :height  "20"} opts)
+    [:path {:d "M512 12.63616c-282.74688 0-512 229.21216-512 512 0 226.22208 146.69824 418.14016 350.12608 485.82656 25.57952 4.73088 35.00032-11.10016 35.00032-24.63744 0-12.20608-0.47104-52.55168-0.69632-95.31392-142.4384 30.96576-172.50304-60.416-172.50304-60.416-23.28576-59.16672-56.85248-74.91584-56.85248-74.91584-46.44864-31.78496 3.50208-31.1296 3.50208-31.1296 51.4048 3.60448 78.47936 52.75648 78.47936 52.75648 45.6704 78.27456 119.76704 55.64416 149.01248 42.55744 4.58752-33.09568 17.85856-55.68512 32.50176-68.46464-113.72544-12.94336-233.2672-56.85248-233.2672-253.0304 0-55.88992 20.00896-101.5808 52.75648-137.4208-5.3248-12.9024-22.85568-64.96256 4.95616-135.49568 0 0 43.008-13.74208 140.84096 52.49024 40.83712-11.34592 84.64384-17.03936 128.16384-17.24416 43.49952 0.2048 87.32672 5.87776 128.24576 17.24416 97.73056-66.2528 140.65664-52.49024 140.65664-52.49024 27.87328 70.53312 10.3424 122.59328 5.03808 135.49568 32.82944 35.86048 52.69504 81.53088 52.69504 137.4208 0 196.64896-119.78752 239.94368-233.79968 252.6208 18.37056 15.89248 34.73408 47.04256 34.73408 94.80192 0 68.5056-0.59392 123.63776-0.59392 140.51328 0 13.6192 9.216 29.5936 35.16416 24.576 203.32544-67.76832 349.83936-259.62496 349.83936-485.76512 0-282.78784-229.23264-512-512-512z"}]]))
\ No newline at end of file
diff --git a/src/main/frontend/components/theme.cljs b/src/main/frontend/components/theme.cljs
index 8721e3c77a..54eaababda 100644
--- a/src/main/frontend/components/theme.cljs
+++ b/src/main/frontend/components/theme.cljs
@@ -3,19 +3,29 @@
             [frontend.util :as util]
             [frontend.ui :as ui]
             [frontend.handler.route :as route-handler]
+            [frontend.handler.plugin :as plugin-handler]
             [frontend.components.svg :as svg]))
 
 (rum/defc container
-  [{:keys [route theme on-click nfs-granted? db-restoring? system-theme?] :as props} child]
+  [{:keys [route theme on-click current-repo nfs-granted? db-restoring? sidebar-open? system-theme?] :as props} child]
   (rum/use-effect!
    #(let [doc js/document.documentElement
           cls (.-classList doc)]
       (.setAttribute doc "data-theme" (if (= theme "white") "light" theme))
       (if (= theme "dark")                                 ;; for tailwind dark mode
         (.add cls "dark")
-        (.remove cls "dark")))
+        (.remove cls "dark"))
+      (plugin-handler/hook-plugin-app :theme-mode-changed {:mode (if (= theme "white") "light" theme)} nil))
    [theme])
 
+  (rum/use-effect!
+   #(plugin-handler/hook-plugin-app :sidebar-visible-changed {:visible sidebar-open?})
+   [sidebar-open?])
+
+  (rum/use-effect!
+    #(plugin-handler/hook-plugin-app :current-graph-changed {})
+    [current-repo])
+
   (rum/use-effect!
    #(let [db-restored? (false? db-restoring?)]
       (if db-restoring?
diff --git a/src/main/frontend/components/theme.css b/src/main/frontend/components/theme.css
index f90fa8be77..63266a86dc 100644
--- a/src/main/frontend/components/theme.css
+++ b/src/main/frontend/components/theme.css
@@ -101,3 +101,12 @@ html.is-resizing-buf {
     transition: none;
   }
 }
+
+body[data-page=plugins] {
+  .cp__sidebar-main-content {
+    max-width: 1280px;
+    width: 80%;
+    padding-left: 30px;
+    padding-right: 30px;
+  }
+}
\ No newline at end of file
diff --git a/src/main/frontend/core.cljs b/src/main/frontend/core.cljs
index 803ff16886..ca306e47b3 100644
--- a/src/main/frontend/core.cljs
+++ b/src/main/frontend/core.cljs
@@ -1,6 +1,7 @@
 (ns frontend.core
   (:require [rum.core :as rum]
             [frontend.handler :as handler]
+            [frontend.handler.plugin :as plugin-handler]
             [frontend.handler.route :as route]
             [frontend.page :as page]
             [frontend.routes :as routes]
@@ -44,7 +45,8 @@
   ;; this is called in the index.html and must be exported
   ;; so it is available even in :advanced release builds
 
-  (handler/start! start)
+  (plugin-handler/setup!
+   #(handler/start! start))
 
   ;; popup to notify user, could be toggled in settings
   ;; (handler/request-notifications-if-not-asked)
diff --git a/src/main/frontend/dicts.cljs b/src/main/frontend/dicts.cljs
index e85482aa2c..077c7dd40a 100644
--- a/src/main/frontend/dicts.cljs
+++ b/src/main/frontend/dicts.cljs
@@ -259,6 +259,9 @@
         :all-journals "All journals"
         :my-publishing "My publishing"
         :settings "Settings"
+        :plugins "Plugins"
+        :themes "Themes"
+        :developer-mode-alert "If you want enable plugin system just now, please restart app."
         :import "Import"
         :join-community "Join the community"
         :sponsor-us "Sponsor Us"
@@ -910,6 +913,9 @@
            :all-files "所有文件"
            :my-publishing "我的发布"
            :settings "设置"
+           :plugins "插件"
+           :themes "主题"
+           :developer-mode-alert "如果希望插件功能立刻生效, 请重启应用"
            :import "导入"
            :join-community "加入社区"
            :sponsor-us "赞助我们!"
diff --git a/src/main/frontend/fs.cljs b/src/main/frontend/fs.cljs
index b3749ae512..0aef5231ed 100644
--- a/src/main/frontend/fs.cljs
+++ b/src/main/frontend/fs.cljs
@@ -138,9 +138,10 @@
   ([repo dir path]
    (create-if-not-exists repo dir path ""))
   ([repo dir path initial-content]
-   (let [path (if (util/starts-with? path "/")
-                path
-                (str "/" path))]
+   (let [path (if (util/absolute-path? path) path
+                  (if (util/starts-with? path "/")
+                    path
+                    (str "/" path)))]
      (->
       (p/let [stat (stat dir path)]
         true)
diff --git a/src/main/frontend/fs/node.cljs b/src/main/frontend/fs/node.cljs
index f2894be8e7..905b43fb9a 100644
--- a/src/main/frontend/fs/node.cljs
+++ b/src/main/frontend/fs/node.cljs
@@ -24,32 +24,42 @@
            (str "/" (string/replace path #"^/" ""))))))
 
 (defn- write-file-impl!
-  [this repo dir path content {:keys [ok-handler error-handler] :as opts} stat]
-  (p/let [disk-mtime (when stat (gobj/get stat "mtime"))
-          db-mtime (db/get-file-last-modified-at repo path)
-          old-content nil
-          old-content (-> (protocol/read-file this dir path nil)
-                          (p/catch (fn [error]
-                                     "")))
-          ext (string/lower-case (util/get-file-ext path))]
-    (if (and
-         (and (not= disk-mtime db-mtime)
-              (not= (string/trim old-content) (string/trim content)))
-         ;; FIXME:
-         (not (contains? #{"excalidraw" "edn"} ext)))
-      (js/alert (str "The file has been modified on your local disk! File path: " path
-                     ", please save your changes and click the refresh button to reload it."))
-      (->
-       (p/let [result (ipc/ipc "writeFile" path content)
-               mtime (gobj/get result "mtime")]
-         (db/set-file-last-modified-at! repo path mtime)
-         (when ok-handler
-           (ok-handler repo path result))
-         result)
-       (p/catch (fn [error]
-                  (if error-handler
-                    (error-handler error)
-                    (log/error :write-file-failed error))))))))
+  [this repo dir path content {:keys [ok-handler error-handler skip-mtime?] :as opts} stat]
+  (if skip-mtime?
+    (p/catch
+     (p/let [result (ipc/ipc "writeFile" path content)]
+       (when ok-handler
+         (ok-handler repo path result)))
+     (fn [error]
+       (if error-handler
+         (error-handler error)
+         (log/error :write-file-failed error))))
+
+    (p/let [disk-mtime (when stat (gobj/get stat "mtime"))
+            db-mtime (db/get-file-last-modified-at repo path)
+            old-content nil
+            old-content (-> (protocol/read-file this dir path nil)
+                            (p/catch (fn [error]
+                                       "")))
+            ext (string/lower-case (util/get-file-ext path))]
+      (if (and
+           (and (not= disk-mtime db-mtime)
+                (not= (string/trim old-content) (string/trim content)))
+            ;; FIXME:
+           (not (contains? #{"excalidraw" "edn"} ext)))
+        (js/alert (str "The file has been modified on your local disk! File path: " path
+                       ", please save your changes and click the refresh button to reload it."))
+        (->
+         (p/let [result (ipc/ipc "writeFile" path content)
+                 mtime (gobj/get result "mtime")]
+           (db/set-file-last-modified-at! repo path mtime)
+           (when ok-handler
+             (ok-handler repo path result))
+           result)
+         (p/catch (fn [error]
+                    (if error-handler
+                      (error-handler error)
+                      (log/error :write-file-failed error)))))))))
 
 (defrecord Node []
   protocol/Fs
diff --git a/src/main/frontend/handler/editor.cljs b/src/main/frontend/handler/editor.cljs
index a4156dc9c3..87e5a8b22a 100644
--- a/src/main/frontend/handler/editor.cljs
+++ b/src/main/frontend/handler/editor.cljs
@@ -875,9 +875,11 @@
                                           :block/properties properties
                                           :block/content content})]
           (outliner-core/save-node block)
-          (let [opts {:key :block/change
-                      :data [block]}]
-            (db/refresh! repo opts)))))))
+
+          ;; update editing input content
+          (when-let [editing-block (state/get-edit-block)]
+            (and (= (:block/uuid editing-block) block-id)
+                 (state/set-edit-content! (state/get-edit-input-id) content))))))))
 
 (defn remove-block-property!
   [block-id key]
diff --git a/src/main/frontend/handler/plugin.cljs b/src/main/frontend/handler/plugin.cljs
new file mode 100644
index 0000000000..d8755132e5
--- /dev/null
+++ b/src/main/frontend/handler/plugin.cljs
@@ -0,0 +1,212 @@
+(ns frontend.handler.plugin
+  (:require [promesa.core :as p]
+            [rum.core :as rum]
+            [frontend.util :as util]
+            [frontend.fs :as fs]
+            [frontend.format.mldoc :refer [->MldocMode] :as mldoc]
+            [frontend.handler.notification :as notifications]
+            [frontend.storage :as storage]
+            [camel-snake-kebab.core :as csk]
+            [frontend.state :as state]
+            [medley.core :as md]
+            [electron.ipc :as ipc]
+            [cljs-bean.core :as bean]
+            [clojure.string :as string]
+            [lambdaisland.glogi :as log]
+            [frontend.format :as format]))
+
+(defonce lsp-enabled?
+  (and (util/electron?)
+       (= (storage/get "developer-mode") "true")))
+
+(defn invoke-exported-api
+  [type & args]
+  (try
+    (apply js-invoke js/logseq.api type args)
+    (catch js/Error e (js/console.error e))))
+
+;; state handlers
+(defn register-plugin
+  [pl]
+  (swap! state/state update-in [:plugin/installed-plugins] assoc (keyword (:id pl)) pl))
+
+(defn unregister-plugin
+  [id]
+  (js/LSPluginCore.unregister id))
+
+(defn host-mounted!
+  []
+  (and lsp-enabled? (js/LSPluginCore.hostMounted)))
+
+(defn register-plugin-slash-command
+  [pid [cmd actions]]
+  (prn (if-let [pid (keyword pid)]
+         (when (contains? (:plugin/installed-plugins @state/state) pid)
+           (do (swap! state/state update-in [:plugin/installed-commands pid]
+                      (fnil merge {}) (hash-map cmd (mapv #(conj % {:pid pid}) actions)))
+               true)))))
+
+(defn unregister-plugin-slash-command
+  [pid]
+  (swap! state/state md/dissoc-in [:plugin/installed-commands (keyword pid)]))
+
+(defn register-plugin-simple-command
+  ;; action => [:action-key :event-key]
+  [pid {:keys [key label type] :as cmd}  action]
+  (if-let [pid (keyword pid)]
+    (when (contains? (:plugin/installed-plugins @state/state) pid)
+      (do (swap! state/state update-in [:plugin/simple-commands pid]
+                 (fnil conj []) [type cmd action pid])
+          true))))
+
+(defn unregister-plugin-simple-command
+  [pid]
+  (swap! state/state md/dissoc-in [:plugin/simple-commands (keyword pid)]))
+
+(defn update-plugin-settings
+  [id settings]
+  (swap! state/state update-in [:plugin/installed-plugins id] assoc :settings settings))
+
+(defn parse-user-md-content
+  [content {:keys [url]}]
+  (try
+    (if-not (string/blank? content)
+      (let [content (if-not (string/blank? url)
+                      (string/replace
+                       content #"!\[[^\]]*\]\((.*?)\s*(\"(?:.*[^\"])\")?\s*\)"
+                       (fn [[matched link]]
+                         (if (and link (not (string/starts-with? link "http")))
+                           (string/replace matched link (util/node-path.join url link))
+                           matched)))
+                      content)]
+        (format/to-html content :markdown (mldoc/default-config :markdown false))))
+    (catch js/Error e
+      (log/error :parse-user-md-exception e)
+      content)))
+
+(defn open-readme!
+  [url item display]
+  (when url
+    (-> (p/let [content (invoke-exported-api "load_plugin_readme" url)
+                content (parse-user-md-content content item)]
+          (state/set-state! :plugin/active-readme [content item])
+          (state/set-modal! display))
+        (p/catch #(notifications/show! "No README file." :warn)))))
+
+(defn load-unpacked-plugin
+  []
+  (if util/electron?
+    (p/let [path (ipc/ipc "openDialogSync")]
+      (when-not (:plugin/selected-unpacked-pkg @state/state)
+        (state/set-state! :plugin/selected-unpacked-pkg path)))))
+
+(defn reset-unpacked-state
+  []
+  (state/set-state! :plugin/selected-unpacked-pkg nil))
+
+(defn hook-plugin
+  [tag type payload plugin-id]
+  (when lsp-enabled?
+    (js-invoke js/LSPluginCore
+               (str "hook" (string/capitalize (name tag)))
+               (name type)
+               (if (coll? payload)
+                 (bean/->js (into {} (for [[k v] payload] [(csk/->camelCase k) (if (uuid? v) (str v) v)])))
+                 payload)
+               (if (keyword? plugin-id) (name plugin-id) plugin-id))))
+
+(defn hook-plugin-app
+  ([type payload] (hook-plugin-app type payload nil))
+  ([type payload plugin-id] (hook-plugin :app type payload plugin-id)))
+
+(defn hook-plugin-editor
+  ([type payload] (hook-plugin-editor type payload nil))
+  ([type payload plugin-id] (hook-plugin :editor type payload plugin-id)))
+
+(defn get-ls-dotdir-root
+  []
+  (ipc/ipc "getLogseqDotDirRoot"))
+
+(defn- get-user-default-plugins
+  []
+  (p/catch
+   (p/let [files ^js (ipc/ipc "getUserDefaultPlugins")
+           files (js->clj files)]
+     (map #(hash-map :url %) files))
+   (fn [e]
+     (js/console.error e))))
+
+;; components
+(rum/defc lsp-indicator < rum/reactive
+  []
+  (let [text (state/sub :plugin/indicator-text)]
+    (if (= text "END")
+      [:span]
+      [:div
+       {:style
+        {:width           "100%"
+         :height          "100vh"
+         :display         "flex"
+         :align-items     "center"
+         :justify-content "center"}}
+       [:span
+        {:style
+         {:color     "#aaa"
+          :font-size "38px"}} (or text "Loading ...")]])))
+
+(defn init-plugins
+  [callback]
+
+  (let [el (js/document.createElement "div")]
+    (.appendChild js/document.body el)
+    (rum/mount
+     (lsp-indicator) el))
+
+  (state/set-state! :plugin/indicator-text "Loading...")
+
+  (p/then
+   (p/let [root (get-ls-dotdir-root)
+           _ (.setupPluginCore js/LSPlugin (bean/->js {:localUserConfigRoot root}))
+           _ (doto js/LSPluginCore
+               (.on "registered"
+                    (fn [^js pl]
+                      (register-plugin
+                       (bean/->clj (.parse js/JSON (.stringify js/JSON pl))))))
+
+               (.on "unregistered" (fn [pid]
+                                     (let [pid (keyword pid)]
+                                        ;; plugins
+                                       (swap! state/state md/dissoc-in [:plugin/installed-plugins (keyword pid)])
+                                        ;; commands
+                                       (unregister-plugin-slash-command pid))))
+
+               (.on "theme-changed" (fn [^js themes]
+                                      (swap! state/state assoc :plugin/installed-themes
+                                             (vec (mapcat (fn [[_ vs]] (bean/->clj vs)) (bean/->clj themes))))))
+
+               (.on "theme-selected" (fn [^js opts]
+                                       (let [opts (bean/->clj opts)
+                                             url (:url opts)
+                                             mode (:mode opts)]
+                                         (when mode (state/set-theme! mode))
+                                         (state/set-state! :plugin/selected-theme url))))
+
+               (.on "settings-changed" (fn [id ^js settings]
+                                         (let [id (keyword id)]
+                                           (when (and settings
+                                                      (contains? (:plugin/installed-plugins @state/state) id))
+                                             (update-plugin-settings id (bean/->clj settings)))))))
+
+           default-plugins (get-user-default-plugins)
+
+           _ (.register js/LSPluginCore (bean/->js (if (seq default-plugins) default-plugins [])) true)])
+   #(do
+      (state/set-state! :plugin/indicator-text "END")
+      (callback))))
+
+(defn setup!
+  "setup plugin core handler"
+  [callback]
+  (if (not lsp-enabled?)
+    (callback)
+    (init-plugins callback)))
diff --git a/src/main/frontend/handler/route.cljs b/src/main/frontend/handler/route.cljs
index 53a7969475..d65b6da4cc 100644
--- a/src/main/frontend/handler/route.cljs
+++ b/src/main/frontend/handler/route.cljs
@@ -3,6 +3,7 @@
             [reitit.frontend.easy :as rfe]
             [reitit.frontend.history :as rfh]
             [frontend.state :as state]
+            [frontend.handler.plugin :as plugin-handler]
             [goog.dom :as gdom]
             [frontend.handler.ui :as ui-handler]
             [frontend.db :as db]
@@ -77,6 +78,11 @@
         title (get-title (:name data) path-params)]
     (util/set-title! title)))
 
+(defn update-page-label!
+  [route]
+  (let [{:keys [data]} route]
+    (set! (. js/document.body.dataset -page) (name (:name data)))))
+
 (defn jump-to-anchor!
   [anchor-text]
   (when anchor-text
@@ -87,11 +93,13 @@
   (let [route route]
     (swap! state/state assoc :route-match route)
     (update-page-title! route)
+    (update-page-label! route)
     (if-let [anchor (get-in route [:query-params :anchor])]
       (jump-to-anchor! anchor)
       (util/scroll-to (util/app-scroll-container-node)
                       (state/get-saved-scroll-position)
-                      false))))
+                      false))
+    (plugin-handler/hook-plugin-app :route-changed (select-keys route [:template :path :parameters]))))
 
 (defn go-to-search!
   [search-mode]
diff --git a/src/main/frontend/page.cljs b/src/main/frontend/page.cljs
index 9b8630114c..f403a4a243 100644
--- a/src/main/frontend/page.cljs
+++ b/src/main/frontend/page.cljs
@@ -3,6 +3,7 @@
             [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.components.sidebar :as sidebar]
+            [frontend.handler.plugin :as plugin-handler]
             [frontend.context.i18n :as i18n]))
 
 (rum/defc route-view
@@ -15,6 +16,7 @@
                    (state/setup-electron-updater!)
                    (ui/inject-document-devices-envs!)
                    (ui/inject-dynamic-style-node!)
+                   (plugin-handler/host-mounted!)
                    (let [teardown-fn (comp (ui/setup-patch-ios-fixed-bottom-position!))]
                      (assoc state ::teardown teardown-fn)))
    :will-unmount (fn [state]
diff --git a/src/main/frontend/routes.cljs b/src/main/frontend/routes.cljs
index 8f237898d3..051729d366 100644
--- a/src/main/frontend/routes.cljs
+++ b/src/main/frontend/routes.cljs
@@ -4,6 +4,7 @@
             [frontend.components.file :as file]
             [frontend.components.page :as page]
             [frontend.components.diff :as diff]
+            [frontend.components.plugins :as plugins]
             [frontend.components.journal :as journal]
             [frontend.components.search :as search]
             [frontend.components.settings :as settings]
@@ -64,6 +65,10 @@
     {:name :all-journals
      :view journal/all-journals}]
 
+   ["/plugins"
+    {:name :plugins
+     :view plugins/installed-page}]
+
    ["/helper/shortcut"
     {:name :shortcut
      :view shortcut/shortcut}]])
diff --git a/src/main/frontend/state.cljs b/src/main/frontend/state.cljs
index 9452fb583f..482ae1a9e5 100644
--- a/src/main/frontend/state.cljs
+++ b/src/main/frontend/state.cljs
@@ -118,6 +118,16 @@
     :electron/updater-pending? false
     :electron/updater {}
 
+    ;; plugin
+    :plugin/indicator-text        nil
+    :plugin/installed-plugins     {}
+    :plugin/installed-themes      []
+    :plugin/installed-commands    {}
+    :plugin/simple-commands       {}
+    :plugin/selected-theme        nil
+    :plugin/selected-unpacked-pkg nil
+    :plugin/active-readme         nil
+
     ;; all notification contents as k-v pairs
     :notification/contents {}
     :graph/syncing? false
@@ -1087,6 +1097,15 @@
   []
   (:commands (get-config)))
 
+(defn get-plugins-commands
+  []
+  (mapcat seq (flatten (vals (:plugin/installed-commands @state)))))
+
+(defn get-plugins-commands-with-type
+  [type]
+  (filterv #(= (keyword (first %)) (keyword type))
+           (apply concat (vals (:plugin/simple-commands @state)))))
+
 (defn get-scheduled-future-days
   []
   (let [days (:scheduled/future-days (get-config))]
diff --git a/src/main/frontend/util.cljc b/src/main/frontend/util.cljc
index c9b2764933..fd79e6192f 100644
--- a/src/main/frontend/util.cljc
+++ b/src/main/frontend/util.cljc
@@ -940,6 +940,14 @@
 (defonce win32? #?(:cljs goog.userAgent/WINDOWS
                    :clj nil))
 
+#?(:cljs
+   (defn absolute-path?
+     [path]
+     (try
+       (js/window.apis.isAbsolutePath path)
+       (catch js/Error _
+         (node-path.isAbsolute path)))))
+
 (defn ->system-modifier
   [keyboard-shortcut]
   (if mac?
diff --git a/src/main/logseq/api.cljs b/src/main/logseq/api.cljs
index 4f669a3e4b..2a0d6bbd37 100644
--- a/src/main/logseq/api.cljs
+++ b/src/main/logseq/api.cljs
@@ -1,10 +1,346 @@
 (ns ^:no-doc logseq.api
   (:require [frontend.db :as db]
+            [frontend.db.model :as db-model]
+            [frontend.db.utils :as db-utils]
+            [frontend.handler.block :as block-handler]
+            [frontend.handler.editor :as editor-handler]
+            [frontend.handler.dnd :as editor-dnd-handler]
+            [frontend.modules.outliner.core :as outliner]
+            [frontend.modules.outliner.tree :as outliner-tree]
+            [frontend.util :as util]
+            [frontend.config :as config]
+            [frontend.util.cursor :as cursor]
+            [electron.ipc :as ipc]
+            [promesa.core :as p]
+            [goog.dom :as gdom]
+            [sci.core :as sci]
+            [lambdaisland.glogi :as log]
+            [camel-snake-kebab.core :as csk]
+            [cljs-bean.core :as bean]
             [frontend.state :as state]
+            [frontend.components.plugins :as plugins]
+            [frontend.handler.plugin :as plugin-handler]
+            [frontend.commands :as commands]
+            [frontend.handler.notification :as notification]
             [datascript.core :as d]
+            [medley.core :as medley]
+            [frontend.fs :as fs]
+            [clojure.string :as string]
+            [clojure.walk :as walk]
             [cljs.reader]
+            [reitit.frontend.easy :as rfe]
             [frontend.db.query-dsl :as query-dsl]))
 
+;; helpers
+(defn- normalize-keyword-for-json
+  [input]
+  (when input
+    (walk/postwalk
+     (fn [a]
+       (cond
+         (keyword? a) (csk/->camelCase (name a))
+         (uuid? a) (str a)
+         :else a)) input)))
+
+(defn- parse-hiccup-ui
+  [input]
+  (when (string? input)
+    (try
+      (sci/eval-string input {:preset :termination-safe})
+      (catch js/Error e
+        (js/console.error "[parse hiccup error]" e) input))))
+
+;; base
+(def ^:export get_user_configs
+  (fn []
+    (bean/->js
+     (normalize-keyword-for-json
+      {:preferred-language   (:preferred-language @state/state)
+       :preferred-theme-mode (if (= (:ui/theme @state/state) "light") "white" "dark")
+       :preferred-format     (state/get-preferred-format)
+       :preferred-workflow   (state/get-preferred-workflow)
+       :preferred-todo       (state/get-preferred-todo)
+       :current-graph        (state/get-current-repo)
+       :me                   (state/get-me)}))))
+
+(def ^:export get_current_graph
+  (fn []
+    (when-let [repo (state/get-current-repo)]
+      (when-not (= config/local-repo repo)
+        (bean/->js {:url repo
+                    :name (util/node-path.basename repo)
+                    :path (config/get-repo-dir repo)})))))
+
+(def ^:export show_themes
+  (fn []
+    (plugins/open-select-theme!)))
+
+(def ^:export set_theme_mode
+  (fn [mode]
+    (state/set-theme! (if (= mode "light") "white" "dark"))))
+
+(def ^:export load_plugin_config
+  (fn [path]
+    (fs/read-file "" (util/node-path.join path "package.json"))))
+
+(def ^:export load_plugin_readme
+  (fn [path]
+    (fs/read-file "" (util/node-path.join path "readme.md"))))
+
+(def ^:export save_plugin_config
+  (fn [path ^js data]
+    (let [repo ""
+          path (util/node-path.join path "package.json")]
+      (fs/write-file! repo "" path (js/JSON.stringify data nil 2) {:skip-mtime? true}))))
+
+(def ^:export write_user_tmp_file
+  (fn [file content]
+    (p/let [repo ""
+            path (plugin-handler/get-ls-dotdir-root)
+            path (util/node-path.join path "tmp")
+            exist? (fs/file-exists? path "")
+            _ (when-not exist? (fs/mkdir! path))
+            path (util/node-path.join path file)
+            _ (fs/write-file! repo "" path content {:skip-mtime? true})]
+      path)))
+
+(def ^:export load_user_preferences
+  (fn []
+    (p/let [repo ""
+            path (plugin-handler/get-ls-dotdir-root)
+            path (util/node-path.join path "preferences.json")
+            _ (fs/create-if-not-exists repo "" path)
+            json (fs/read-file "" path)
+            json (if (string/blank? json) "{}" json)]
+      (js/JSON.parse json))))
+
+(def ^:export save_user_preferences
+  (fn [^js data]
+    (when data
+      (p/let [repo ""
+              path (plugin-handler/get-ls-dotdir-root)
+              path (util/node-path.join path "preferences.json")]
+        (fs/write-file! repo "" path (js/JSON.stringify data nil 2) {:skip-mtime? true})))))
+
+(def ^:export load_plugin_user_settings
+  (fn [key]
+    (p/let [repo ""
+            path (plugin-handler/get-ls-dotdir-root)
+            exist? (fs/file-exists? path "settings")
+            _ (when-not exist? (fs/mkdir! (util/node-path.join path "settings")))
+            path (util/node-path.join path "settings" (str key ".json"))
+            _ (fs/create-if-not-exists repo "" path "{}")
+            json (fs/read-file "" path)]
+      [path (js/JSON.parse json)])))
+
+(def ^:export save_plugin_user_settings
+  (fn [key ^js data]
+    (p/let [repo ""
+            path (plugin-handler/get-ls-dotdir-root)
+            path (util/node-path.join path "settings" (str key ".json"))]
+      (fs/write-file! repo "" path (js/JSON.stringify data nil 2) {:skip-mtime? true}))))
+
+(def ^:export register_plugin_slash_command
+  (fn [pid ^js cmd-actions]
+    (when-let [[cmd actions] (bean/->clj cmd-actions)]
+      (plugin-handler/register-plugin-slash-command
+       pid [cmd (mapv #(into [(keyword (first %))]
+                             (rest %)) actions)]))))
+
+(def ^:export register_plugin_simple_command
+  (fn [pid ^js cmd-action]
+    (when-let [[cmd action] (bean/->clj cmd-action)]
+      (plugin-handler/register-plugin-simple-command
+       pid cmd (assoc action 0 (keyword (first action)))))))
+
+;; app
+(def ^:export relaunch
+  (fn []
+    (ipc/ipc "relaunchApp")))
+
+(def ^:export quit
+  (fn []
+    (ipc/ipc "quitApp")))
+
+(def ^:export push_state
+  (fn [^js k ^js params]
+    (rfe/push-state
+     (keyword k) (bean/->clj params))))
+
+(def ^:export replace_state
+  (fn [^js k ^js params]
+    (rfe/replace-state
+     (keyword k) (bean/->clj params))))
+
+;; editor
+(def ^:export check_editing
+  (fn []
+    (if (state/get-edit-input-id)
+      (str (:block/uuid (state/get-edit-block))) false)))
+
+(def ^:export exit_editing_mode
+  (fn [select?]
+    (when-let [block (state/get-edit-block)]
+      (if select?
+        (editor-handler/select-block! (:block/uuid block))
+        (state/clear-edit!)))
+    nil))
+
+(def ^:export insert_at_editing_cursor
+  (fn [content]
+    (when-let [input-id (state/get-edit-input-id)]
+      (commands/simple-insert! input-id content {})
+      (.focus (gdom/getElement input-id)))))
+
+(def ^:export restore_editing_cursor
+  (fn []
+    (when-let [input-id (state/get-edit-input-id)]
+      (.focus (gdom/getElement input-id)))))
+
+(def ^:export get_editing_cursor_position
+  (fn []
+    (when-let [input-id (state/get-edit-input-id)]
+      (bean/->js (normalize-keyword-for-json (cursor/get-caret-pos (gdom/getElement input-id)))))))
+
+(def ^:export get_editing_block_content
+  (fn []
+    (state/get-edit-content)))
+
+(def ^:export get_current_block
+  (fn []
+    (let [block (state/get-edit-block)
+          block (or block (state/get-last-edit-block))
+          block (and block (db-utils/pull (:db/id block)))]
+      (bean/->js (normalize-keyword-for-json block)))))
+
+(def ^:export get_current_page
+  (fn []
+    (when-let [page (state/get-current-page)]
+      (when-let [page (db-model/get-page page)]
+        (bean/->js (normalize-keyword-for-json (db-utils/pull (:db/id page))))))))
+
+(def ^:export get_page
+  (fn [id-or-page-name]
+    (when-let [page (cond
+                      (number? id-or-page-name) (db-utils/pull id-or-page-name)
+                      (string? id-or-page-name) (db-model/get-page id-or-page-name))]
+      (if-not (contains? page :block/left)
+        (bean/->js (normalize-keyword-for-json (db-utils/pull (:db/id page))))))))
+
+(def ^:export edit_block
+  (fn [block-uuid {:keys [pos] :or {pos :max} :as opts}]
+    (when-let [block-uuid (and block-uuid (medley/uuid block-uuid))]
+      (when-let [block (db-model/query-block-by-uuid block-uuid)]
+        (editor-handler/edit-block! block pos nil block-uuid)))))
+
+(def ^:export insert_block
+  (fn [block-uuid-or-page-name content ^js opts]
+    (let [{:keys [before sibling isPageBlock props]} (bean/->clj opts)
+          page-name (and isPageBlock block-uuid-or-page-name)
+          block-uuid (if isPageBlock nil (medley/uuid block-uuid-or-page-name))
+          new-block (editor-handler/api-insert-new-block!
+                     content {:block-uuid block-uuid :sibling? sibling :page page-name})]
+
+      (bean/->js (normalize-keyword-for-json new-block)))))
+
+(def ^:export insert_batch_block
+  (fn [block-uuid ^js batch-blocks ^js opts]
+    (when-let [block (db-model/query-block-by-uuid block-uuid)]
+      (when-let [bb (bean/->clj batch-blocks)]
+        (let [bb (if-not (vector? bb) (vector bb) bb)
+              {:keys [sibling]} (bean/->clj opts)
+              _ (editor-handler/paste-block-tree-after-target
+                 (:db/id block) sibling bb (:block/format block))]
+          nil)))))
+
+(def ^:export remove_block
+  (fn [block-uuid ^js opts]
+    (let [{:keys [includeChildren]} (bean/->clj opts)
+          repo (state/get-current-repo)]
+      (editor-handler/delete-block-aux!
+       {:block/uuid (medley/uuid block-uuid) :repo repo} includeChildren))))
+
+(def ^:export update_block
+  (fn [block-uuid content ^js opts]
+    (let [opts (and opts (bean/->clj opts))
+          repo (state/get-current-repo)
+          editing? (string/ends-with? (state/get-edit-input-id) block-uuid)]
+
+      (if editing?
+        (state/set-edit-content! (state/get-edit-input-id) content)
+        (editor-handler/save-block! repo (medley/uuid block-uuid) content))
+      nil)))
+
+(def ^:export move_block
+  (fn [src-block-uuid target-block-uuid ^js opts]
+
+    (let [{:keys [before children]} (bean/->clj opts)
+          top? (boolean before)
+          nested? (boolean children)
+          src-block-uuid (db-model/query-block-by-uuid (medley/uuid src-block-uuid))
+          target-block-uuid (db-model/query-block-by-uuid (medley/uuid target-block-uuid))]
+      (editor-dnd-handler/move-block src-block-uuid target-block-uuid top? nested?))))
+
+(def ^:export get_block
+  (fn [id-or-uuid ^js opts]
+    (when-let [block (cond
+                       (number? id-or-uuid) (db-utils/pull id-or-uuid)
+                       (string? id-or-uuid) (db-model/query-block-by-uuid id-or-uuid))]
+      (if-not (contains? block :block/name)
+        (when-let [uuid (:block/uuid block)]
+          (let [{:keys [includeChildren]} (bean/->clj opts)
+                block (if (not includeChildren) block (first (outliner-tree/blocks->vec-tree [block] uuid)))]
+            (bean/->js (normalize-keyword-for-json block))))))))
+
+(def ^:export get_previous_sibling_block
+  (fn [uuid]
+    (when-let [block (db-model/query-block-by-uuid uuid)]
+      (let [{:block/keys [parent left]} block
+            block (if-not (= parent left) (db-utils/pull (:db/id left)))]
+        (and block (bean/->js (normalize-keyword-for-json block)))))))
+
+(def ^:export get_next_sibling_block
+  (fn [uuid]
+    (when-let [block (db-model/query-block-by-uuid uuid)]
+      (when-let [right-siblings (outliner/get-right-siblings (outliner/->Block block))]
+        (bean/->js (normalize-keyword-for-json (:data (first right-siblings))))))))
+
+(def ^:export upsert_block_property
+  (fn [block-uuid key value]
+    (editor-handler/set-block-property! (medley/uuid block-uuid) key value)))
+
+(def ^:export remove_block_property
+  (fn [block-uuid key]
+    (editor-handler/remove-block-property! (medley/uuid block-uuid) key)))
+
+(def ^:export get_block_property
+  (fn [block-uuid key]
+    (when-let [block (db-model/query-block-by-uuid block-uuid)]
+      (get (:block/properties block) (keyword key)))))
+
+(def ^:export get_block_properties
+  (fn [block-uuid]
+    (when-let [block (db-model/query-block-by-uuid block-uuid)]
+      (bean/->js (normalize-keyword-for-json (:block/properties block))))))
+
+(def ^:export get_current_page_blocks_tree
+  (fn []
+    (when-let [page (state/get-current-page)]
+      (let [blocks (db-model/get-page-blocks-no-cache page)
+            blocks (outliner-tree/blocks->vec-tree blocks page)
+            ;; clean key
+            blocks (normalize-keyword-for-json blocks)]
+        (bean/->js blocks)))))
+
+(def ^:export get_page_blocks_tree
+  (fn [page-name]
+    (when-let [_ (db-model/get-page page-name)]
+      (let [blocks (db-model/get-page-blocks-no-cache page-name)
+            blocks (outliner-tree/blocks->vec-tree blocks page-name)
+            blocks (normalize-keyword-for-json blocks)]
+        (bean/->js blocks)))))
+
+;; db
 (defn ^:export q
   [query-string]
   (when-let [repo (state/get-current-repo)]
@@ -21,3 +357,10 @@
         (clj->js result)))))
 
 (def ^:export custom_query db/custom-query)
+
+;; helpers
+(defn ^:export show_msg
+  ([content] (show_msg content :success))
+  ([content status] (let [hiccup? (and (string? content) (string/starts-with? (string/triml content) "[:"))
+                          content (if hiccup? (parse-hiccup-ui content) content)]
+                      (notification/show! content (keyword status)))))