This is page 8 of 10. Use http://codebase.md/jakedismo/master-mcp-server?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .env.example
├── .eslintignore
├── .eslintrc.cjs
├── .eslintrc.js
├── .gitignore
├── .prettierignore
├── .prettierrc
├── .prettierrc.json
├── CHANGELOG.md
├── config
│ ├── default.json
│ ├── development.json
│ ├── production.json
│ └── schema.json
├── config.json
├── CONTRIBUTING.md
├── debug-stdio.cjs
├── debug-stdio.js
├── deploy
│ ├── cloudflare
│ │ ├── .gitkeep
│ │ ├── README.md
│ │ └── wrangler.toml
│ ├── docker
│ │ ├── .gitkeep
│ │ ├── docker-compose.yml
│ │ ├── Dockerfile
│ │ └── entrypoint.sh
│ ├── koyeb
│ │ ├── .gitkeep
│ │ └── koyeb.yaml
│ └── README.md
├── docker-compose.yml
├── Dockerfile
├── docs
│ ├── .DS_Store
│ ├── .vitepress
│ │ ├── cache
│ │ │ └── deps
│ │ │ ├── _metadata.json
│ │ │ ├── chunk-HVR2FF6M.js
│ │ │ ├── chunk-HVR2FF6M.js.map
│ │ │ ├── chunk-P2XGSYO7.js
│ │ │ ├── chunk-P2XGSYO7.js.map
│ │ │ ├── package.json
│ │ │ ├── vitepress___@vue_devtools-api.js
│ │ │ ├── vitepress___@vue_devtools-api.js.map
│ │ │ ├── vitepress___@vueuse_core.js
│ │ │ ├── vitepress___@vueuse_core.js.map
│ │ │ ├── vitepress___@vueuse_integrations_useFocusTrap.js
│ │ │ ├── vitepress___@vueuse_integrations_useFocusTrap.js.map
│ │ │ ├── vitepress___mark__js_src_vanilla__js.js
│ │ │ ├── vitepress___mark__js_src_vanilla__js.js.map
│ │ │ ├── vitepress___minisearch.js
│ │ │ ├── vitepress___minisearch.js.map
│ │ │ ├── vue.js
│ │ │ └── vue.js.map
│ │ ├── config.ts
│ │ ├── dist
│ │ │ ├── 404.html
│ │ │ ├── advanced
│ │ │ │ ├── extensibility.html
│ │ │ │ ├── index.html
│ │ │ │ ├── monitoring.html
│ │ │ │ ├── performance.html
│ │ │ │ └── security.html
│ │ │ ├── api
│ │ │ │ ├── index.html
│ │ │ │ └── README.html
│ │ │ ├── assets
│ │ │ │ ├── advanced_extensibility.md.TrXUn5w5.js
│ │ │ │ ├── advanced_extensibility.md.TrXUn5w5.lean.js
│ │ │ │ ├── advanced_index.md.CPcpUlw_.js
│ │ │ │ ├── advanced_index.md.CPcpUlw_.lean.js
│ │ │ │ ├── advanced_monitoring.md.DTybdNg-.js
│ │ │ │ ├── advanced_monitoring.md.DTybdNg-.lean.js
│ │ │ │ ├── advanced_performance.md.DKmzK0ia.js
│ │ │ │ ├── advanced_performance.md.DKmzK0ia.lean.js
│ │ │ │ ├── advanced_security.md.B-oBD7IB.js
│ │ │ │ ├── advanced_security.md.B-oBD7IB.lean.js
│ │ │ │ ├── api_index.md.Dl1JB08_.js
│ │ │ │ ├── api_index.md.Dl1JB08_.lean.js
│ │ │ │ ├── chunks
│ │ │ │ │ └── framework.CHl2ywxc.js
│ │ │ │ ├── configuration_environment-variables.md.Ddy3P_Wz.js
│ │ │ │ ├── configuration_environment-variables.md.Ddy3P_Wz.lean.js
│ │ │ │ ├── configuration_environment.md.DxcTQ623.js
│ │ │ │ ├── configuration_environment.md.DxcTQ623.lean.js
│ │ │ │ ├── configuration_overview.md.DIkVDv7V.js
│ │ │ │ ├── configuration_overview.md.DIkVDv7V.lean.js
│ │ │ │ ├── configuration_performance.md.DbJdmLrW.js
│ │ │ │ ├── configuration_performance.md.DbJdmLrW.lean.js
│ │ │ │ ├── configuration_reference.md.27IKWqtk.js
│ │ │ │ ├── configuration_reference.md.27IKWqtk.lean.js
│ │ │ │ ├── configuration_security.md.-OOlkzN4.js
│ │ │ │ ├── configuration_security.md.-OOlkzN4.lean.js
│ │ │ │ ├── contributing_dev-setup.md.Ceqh4w-R.js
│ │ │ │ ├── contributing_dev-setup.md.Ceqh4w-R.lean.js
│ │ │ │ ├── contributing_guidelines.md.ZEAX2yVh.js
│ │ │ │ ├── contributing_guidelines.md.ZEAX2yVh.lean.js
│ │ │ │ ├── contributing_index.md.DYq9R6wr.js
│ │ │ │ ├── contributing_index.md.DYq9R6wr.lean.js
│ │ │ │ ├── contributing_maintenance.md.k2bR0IaR.js
│ │ │ │ ├── contributing_maintenance.md.k2bR0IaR.lean.js
│ │ │ │ ├── deployment_cicd.md.Ci2T0UYC.js
│ │ │ │ ├── deployment_cicd.md.Ci2T0UYC.lean.js
│ │ │ │ ├── deployment_cloudflare-workers.md.D2WHsfep.js
│ │ │ │ ├── deployment_cloudflare-workers.md.D2WHsfep.lean.js
│ │ │ │ ├── deployment_docker.md.B8bQDQTo.js
│ │ │ │ ├── deployment_docker.md.B8bQDQTo.lean.js
│ │ │ │ ├── deployment_index.md.ClYeOkpy.js
│ │ │ │ ├── deployment_index.md.ClYeOkpy.lean.js
│ │ │ │ ├── deployment_koyeb.md.B_wJhvF7.js
│ │ │ │ ├── deployment_koyeb.md.B_wJhvF7.lean.js
│ │ │ │ ├── examples_advanced-routing.md.B3CqhLZ7.js
│ │ │ │ ├── examples_advanced-routing.md.B3CqhLZ7.lean.js
│ │ │ │ ├── examples_basic-node.md.CaDZzGlO.js
│ │ │ │ ├── examples_basic-node.md.CaDZzGlO.lean.js
│ │ │ │ ├── examples_cloudflare-worker.md.DwVSz-c7.js
│ │ │ │ ├── examples_cloudflare-worker.md.DwVSz-c7.lean.js
│ │ │ │ ├── examples_index.md.CBF_BLkl.js
│ │ │ │ ├── examples_index.md.CBF_BLkl.lean.js
│ │ │ │ ├── examples_oauth-delegation.md.1hZxoqDl.js
│ │ │ │ ├── examples_oauth-delegation.md.1hZxoqDl.lean.js
│ │ │ │ ├── examples_overview.md.CZN0JbZ7.js
│ │ │ │ ├── examples_overview.md.CZN0JbZ7.lean.js
│ │ │ │ ├── examples_testing.md.Dek4GpNs.js
│ │ │ │ ├── examples_testing.md.Dek4GpNs.lean.js
│ │ │ │ ├── getting-started_concepts.md.D7ON9iGB.js
│ │ │ │ ├── getting-started_concepts.md.D7ON9iGB.lean.js
│ │ │ │ ├── getting-started_installation.md.BKnVqAGg.js
│ │ │ │ ├── getting-started_installation.md.BKnVqAGg.lean.js
│ │ │ │ ├── getting-started_overview.md.DvJDFL2N.js
│ │ │ │ ├── getting-started_overview.md.DvJDFL2N.lean.js
│ │ │ │ ├── getting-started_quickstart-node.md.GOO4aGas.js
│ │ │ │ ├── getting-started_quickstart-node.md.GOO4aGas.lean.js
│ │ │ │ ├── getting-started_quickstart-workers.md.Cpofh8Mj.js
│ │ │ │ ├── getting-started_quickstart-workers.md.Cpofh8Mj.lean.js
│ │ │ │ ├── getting-started.md.DG9ndneo.js
│ │ │ │ ├── getting-started.md.DG9ndneo.lean.js
│ │ │ │ ├── guides_configuration-management.md.B-jwYMbA.js
│ │ │ │ ├── guides_configuration-management.md.B-jwYMbA.lean.js
│ │ │ │ ├── guides_configuration.md.Ci3zYDFA.js
│ │ │ │ ├── guides_configuration.md.Ci3zYDFA.lean.js
│ │ │ │ ├── guides_index.md.CIlq2fmx.js
│ │ │ │ ├── guides_index.md.CIlq2fmx.lean.js
│ │ │ │ ├── guides_module-loading.md.BkJvuRnQ.js
│ │ │ │ ├── guides_module-loading.md.BkJvuRnQ.lean.js
│ │ │ │ ├── guides_oauth-delegation.md.DEOZ-_G0.js
│ │ │ │ ├── guides_oauth-delegation.md.DEOZ-_G0.lean.js
│ │ │ │ ├── guides_request-routing.md.Bdzf0VLg.js
│ │ │ │ ├── guides_request-routing.md.Bdzf0VLg.lean.js
│ │ │ │ ├── guides_testing.md.kYfHqJLu.js
│ │ │ │ ├── guides_testing.md.kYfHqJLu.lean.js
│ │ │ │ ├── inter-italic-cyrillic-ext.r48I6akx.woff2
│ │ │ │ ├── inter-italic-cyrillic.By2_1cv3.woff2
│ │ │ │ ├── inter-italic-greek-ext.1u6EdAuj.woff2
│ │ │ │ ├── inter-italic-greek.DJ8dCoTZ.woff2
│ │ │ │ ├── inter-italic-latin-ext.CN1xVJS-.woff2
│ │ │ │ ├── inter-italic-latin.C2AdPX0b.woff2
│ │ │ │ ├── inter-italic-vietnamese.BSbpV94h.woff2
│ │ │ │ ├── inter-roman-cyrillic-ext.BBPuwvHQ.woff2
│ │ │ │ ├── inter-roman-cyrillic.C5lxZ8CY.woff2
│ │ │ │ ├── inter-roman-greek-ext.CqjqNYQ-.woff2
│ │ │ │ ├── inter-roman-greek.BBVDIX6e.woff2
│ │ │ │ ├── inter-roman-latin-ext.4ZJIpNVo.woff2
│ │ │ │ ├── inter-roman-latin.Di8DUHzh.woff2
│ │ │ │ ├── inter-roman-vietnamese.BjW4sHH5.woff2
│ │ │ │ ├── README.md.BO5r5M9u.js
│ │ │ │ ├── README.md.BO5r5M9u.lean.js
│ │ │ │ ├── style.BQrfSMzK.css
│ │ │ │ ├── troubleshooting_common-issues.md.CScvzWM1.js
│ │ │ │ ├── troubleshooting_common-issues.md.CScvzWM1.lean.js
│ │ │ │ ├── troubleshooting_deployment.md.DUhpqnLE.js
│ │ │ │ ├── troubleshooting_deployment.md.DUhpqnLE.lean.js
│ │ │ │ ├── troubleshooting_errors.md.BSCsEmGc.js
│ │ │ │ ├── troubleshooting_errors.md.BSCsEmGc.lean.js
│ │ │ │ ├── troubleshooting_oauth.md.Cw60Eka3.js
│ │ │ │ ├── troubleshooting_oauth.md.Cw60Eka3.lean.js
│ │ │ │ ├── troubleshooting_performance.md.DxY6LJcT.js
│ │ │ │ ├── troubleshooting_performance.md.DxY6LJcT.lean.js
│ │ │ │ ├── troubleshooting_routing.md.BHN-MDhs.js
│ │ │ │ ├── troubleshooting_routing.md.BHN-MDhs.lean.js
│ │ │ │ ├── troubleshooting_security-best-practices.md.Yiu8E-zt.js
│ │ │ │ ├── troubleshooting_security-best-practices.md.Yiu8E-zt.lean.js
│ │ │ │ ├── tutorials_beginner-getting-started.md.BXObgobW.js
│ │ │ │ ├── tutorials_beginner-getting-started.md.BXObgobW.lean.js
│ │ │ │ ├── tutorials_cloudflare-workers-tutorial.md.MPHsc0aT.js
│ │ │ │ ├── tutorials_cloudflare-workers-tutorial.md.MPHsc0aT.lean.js
│ │ │ │ ├── tutorials_load-balancing-and-resilience.md.Dv9r9jyW.js
│ │ │ │ ├── tutorials_load-balancing-and-resilience.md.Dv9r9jyW.lean.js
│ │ │ │ ├── tutorials_oauth-delegation-github.md.Nq4glqCe.js
│ │ │ │ └── tutorials_oauth-delegation-github.md.Nq4glqCe.lean.js
│ │ │ ├── configuration
│ │ │ │ ├── environment-variables.html
│ │ │ │ ├── environment.html
│ │ │ │ ├── examples.html
│ │ │ │ ├── overview.html
│ │ │ │ ├── performance.html
│ │ │ │ ├── reference.html
│ │ │ │ └── security.html
│ │ │ ├── contributing
│ │ │ │ ├── dev-setup.html
│ │ │ │ ├── guidelines.html
│ │ │ │ ├── index.html
│ │ │ │ └── maintenance.html
│ │ │ ├── deployment
│ │ │ │ ├── cicd.html
│ │ │ │ ├── cloudflare-workers.html
│ │ │ │ ├── docker.html
│ │ │ │ ├── index.html
│ │ │ │ └── koyeb.html
│ │ │ ├── diagrams
│ │ │ │ └── architecture.svg
│ │ │ ├── examples
│ │ │ │ ├── advanced-routing.html
│ │ │ │ ├── basic-node.html
│ │ │ │ ├── cloudflare-worker.html
│ │ │ │ ├── index.html
│ │ │ │ ├── oauth-delegation.html
│ │ │ │ ├── overview.html
│ │ │ │ └── testing.html
│ │ │ ├── getting-started
│ │ │ │ ├── concepts.html
│ │ │ │ ├── installation.html
│ │ │ │ ├── overview.html
│ │ │ │ ├── quick-start.html
│ │ │ │ ├── quickstart-node.html
│ │ │ │ └── quickstart-workers.html
│ │ │ ├── getting-started.html
│ │ │ ├── guides
│ │ │ │ ├── authentication.html
│ │ │ │ ├── client-integration.html
│ │ │ │ ├── configuration-management.html
│ │ │ │ ├── configuration.html
│ │ │ │ ├── index.html
│ │ │ │ ├── module-loading.html
│ │ │ │ ├── oauth-delegation.html
│ │ │ │ ├── request-routing.html
│ │ │ │ ├── server-management.html
│ │ │ │ ├── server-sharing.html
│ │ │ │ └── testing.html
│ │ │ ├── hashmap.json
│ │ │ ├── index.html
│ │ │ ├── logo.svg
│ │ │ ├── README.html
│ │ │ ├── reports
│ │ │ │ └── mcp-compliance-audit.html
│ │ │ ├── troubleshooting
│ │ │ │ ├── common-issues.html
│ │ │ │ ├── deployment.html
│ │ │ │ ├── errors.html
│ │ │ │ ├── index.html
│ │ │ │ ├── oauth.html
│ │ │ │ ├── performance.html
│ │ │ │ ├── routing.html
│ │ │ │ └── security-best-practices.html
│ │ │ ├── tutorials
│ │ │ │ ├── beginner-getting-started.html
│ │ │ │ ├── cloudflare-workers-tutorial.html
│ │ │ │ ├── load-balancing-and-resilience.html
│ │ │ │ └── oauth-delegation-github.html
│ │ │ └── vp-icons.css
│ │ └── theme
│ │ ├── components
│ │ │ ├── ApiPlayground.vue
│ │ │ ├── AuthFlowDemo.vue
│ │ │ ├── CodeTabs.vue
│ │ │ └── ConfigGenerator.vue
│ │ ├── index.ts
│ │ └── style.css
│ ├── advanced
│ │ ├── extensibility.md
│ │ ├── index.md
│ │ ├── monitoring.md
│ │ ├── performance.md
│ │ └── security.md
│ ├── api
│ │ ├── functions
│ │ │ └── createServer.md
│ │ ├── index.md
│ │ ├── interfaces
│ │ │ └── RunningServer.md
│ │ └── README.md
│ ├── architecture
│ │ └── images
│ │ └── mcp_master_architecture.svg
│ ├── configuration
│ │ ├── environment-variables.md
│ │ ├── environment.md
│ │ ├── examples.md
│ │ ├── overview.md
│ │ ├── performance.md
│ │ ├── reference.md
│ │ └── security.md
│ ├── contributing
│ │ ├── dev-setup.md
│ │ ├── guidelines.md
│ │ ├── index.md
│ │ └── maintenance.md
│ ├── deployment
│ │ ├── cicd.md
│ │ ├── cloudflare-workers.md
│ │ ├── docker.md
│ │ ├── docs-site.md
│ │ ├── index.md
│ │ └── koyeb.md
│ ├── examples
│ │ ├── advanced-routing.md
│ │ ├── basic-node.md
│ │ ├── cloudflare-worker.md
│ │ ├── index.md
│ │ ├── oauth-delegation.md
│ │ ├── overview.md
│ │ └── testing.md
│ ├── getting-started
│ │ ├── concepts.md
│ │ ├── installation.md
│ │ ├── overview.md
│ │ ├── quick-start.md
│ │ ├── quickstart-node.md
│ │ └── quickstart-workers.md
│ ├── getting-started.md
│ ├── guides
│ │ ├── authentication.md
│ │ ├── client-integration.md
│ │ ├── configuration-management.md
│ │ ├── configuration.md
│ │ ├── index.md
│ │ ├── module-loading.md
│ │ ├── oauth-delegation.md
│ │ ├── request-routing.md
│ │ ├── server-management.md
│ │ ├── server-sharing.md
│ │ └── testing.md
│ ├── index.html
│ ├── public
│ │ ├── diagrams
│ │ │ └── architecture.svg
│ │ ├── github-social.png
│ │ │ └── image.png
│ │ ├── logo.png
│ │ └── logo.svg
│ ├── README.md
│ ├── stdio-servers.md
│ ├── testing
│ │ └── phase-9-testing-architecture.md
│ ├── troubleshooting
│ │ ├── common-issues.md
│ │ ├── deployment.md
│ │ ├── errors.md
│ │ ├── index.md
│ │ ├── oauth.md
│ │ ├── performance.md
│ │ ├── routing.md
│ │ └── security-best-practices.md
│ └── tutorials
│ ├── beginner-getting-started.md
│ ├── cloudflare-workers-tutorial.md
│ ├── load-balancing-and-resilience.md
│ └── oauth-delegation-github.md
├── examples
│ ├── advanced-routing
│ │ ├── config.yaml
│ │ └── README.md
│ ├── basic-node
│ │ ├── config.yaml
│ │ ├── README.md
│ │ └── server.ts
│ ├── cloudflare-worker
│ │ ├── README.md
│ │ └── worker.ts
│ ├── custom-auth
│ │ ├── config.yaml
│ │ ├── index.ts
│ │ └── README.md
│ ├── multi-server
│ │ ├── config.yaml
│ │ └── README.md
│ ├── oauth-delegation
│ │ └── README.md
│ ├── oauth-node
│ │ ├── config.yaml
│ │ └── README.md
│ ├── performance
│ │ ├── config.yaml
│ │ └── README.md
│ ├── sample-configs
│ │ ├── basic.yaml
│ │ └── simple-setup.yaml
│ ├── security-hardening
│ │ └── README.md
│ ├── stdio-mcp-server.cjs
│ ├── test-mcp-server.js
│ └── test-stdio-server.js
├── LICENSE
├── master-mcp-definition.md
├── package-lock.json
├── package.json
├── README.md
├── reports
│ └── claude_report_20250815_222153.html
├── scripts
│ └── generate-config-docs.ts
├── src
│ ├── auth
│ │ ├── multi-auth-manager.ts
│ │ ├── oauth-providers.ts
│ │ └── token-manager.ts
│ ├── config
│ │ ├── config-loader.ts
│ │ ├── environment-manager.ts
│ │ ├── schema-validator.ts
│ │ └── secret-manager.ts
│ ├── index.ts
│ ├── mcp-server.ts
│ ├── modules
│ │ ├── capability-aggregator.ts
│ │ ├── module-loader.ts
│ │ ├── request-router.ts
│ │ ├── stdio-capability-discovery.ts
│ │ └── stdio-manager.ts
│ ├── oauth
│ │ ├── callback-handler.ts
│ │ ├── flow-controller.ts
│ │ ├── flow-validator.ts
│ │ ├── pkce-manager.ts
│ │ ├── state-manager.ts
│ │ └── web-interface.ts
│ ├── routing
│ │ ├── circuit-breaker.ts
│ │ ├── load-balancer.ts
│ │ ├── retry-handler.ts
│ │ └── route-registry.ts
│ ├── runtime
│ │ ├── node.ts
│ │ └── worker.ts
│ ├── server
│ │ ├── config-manager.ts
│ │ ├── dependency-container.ts
│ │ ├── master-server.ts
│ │ └── protocol-handler.ts
│ ├── types
│ │ ├── auth.ts
│ │ ├── config.ts
│ │ ├── jose-shim.d.ts
│ │ ├── mcp.ts
│ │ └── server.ts
│ └── utils
│ ├── cache.ts
│ ├── crypto.ts
│ ├── dev.ts
│ ├── errors.ts
│ ├── http.ts
│ ├── logger.ts
│ ├── monitoring.ts
│ ├── string.ts
│ ├── time.ts
│ ├── validation.ts
│ └── validators.ts
├── static
│ └── oauth
│ ├── consent.html
│ ├── error.html
│ ├── script.js
│ ├── style.css
│ └── success.html
├── tests
│ ├── _setup
│ │ ├── miniflare.setup.ts
│ │ └── vitest.setup.ts
│ ├── _utils
│ │ ├── log-capture.ts
│ │ ├── mock-fetch.ts
│ │ └── test-server.ts
│ ├── .gitkeep
│ ├── e2e
│ │ ├── flow-controller.express.test.ts
│ │ └── flow-controller.worker.test.ts
│ ├── factories
│ │ ├── configFactory.ts
│ │ ├── mcpFactory.ts
│ │ └── oauthFactory.ts
│ ├── fixtures
│ │ ├── capabilities.json
│ │ └── stdio-server.js
│ ├── integration
│ │ ├── modules.capability-aggregator.test.ts
│ │ ├── modules.module-loader-health.test.ts
│ │ ├── oauth.callback-handler.test.ts
│ │ └── request-router.test.ts
│ ├── mocks
│ │ ├── mcp
│ │ │ └── fake-backend.ts
│ │ └── oauth
│ │ └── mock-oidc-provider.ts
│ ├── perf
│ │ ├── artillery
│ │ │ └── auth-routing.yaml
│ │ └── perf.auth-and-routing.test.ts
│ ├── security
│ │ └── security.oauth-and-input.test.ts
│ ├── servers
│ │ ├── test-auth-simple.js
│ │ ├── test-debug.js
│ │ ├── test-master-mcp.js
│ │ ├── test-mcp-client.js
│ │ ├── test-streaming-both-complete.js
│ │ ├── test-streaming-both-full.js
│ │ ├── test-streaming-both-simple.js
│ │ ├── test-streaming-both.js
│ │ └── test-streaming.js
│ ├── setup
│ │ └── test-setup.ts
│ ├── unit
│ │ ├── auth.multi-auth-manager.test.ts
│ │ ├── auth.token-manager.test.ts
│ │ ├── config.environment-manager.test.ts
│ │ ├── config.schema-validator.test.ts
│ │ ├── config.secret-manager.test.ts
│ │ ├── modules
│ │ │ ├── stdio-capability-discovery.test.ts
│ │ │ └── stdio-manager.test.ts
│ │ ├── modules.route-registry.test.ts
│ │ ├── oauth.pkce-state.test.ts
│ │ ├── routing
│ │ │ └── circuit-breaker.test.ts
│ │ ├── routing.core.test.ts
│ │ ├── stdio-capability-discovery.test.ts
│ │ ├── utils.crypto.test.ts
│ │ ├── utils.logger.test.ts
│ │ └── utils.monitoring.test.ts
│ └── utils
│ ├── fake-express.ts
│ ├── mock-http.ts
│ ├── oauth-mocks.ts
│ └── token-storages.ts
├── tsconfig.base.json
├── tsconfig.json
├── tsconfig.node.json
├── tsconfig.worker.json
├── typedoc.json
├── vitest.config.ts
└── vitest.worker.config.ts
```
# Files
--------------------------------------------------------------------------------
/docs/.vitepress/cache/deps/vitepress___@vue_devtools-api.js:
--------------------------------------------------------------------------------
```javascript
1 | // node_modules/@vue/devtools-shared/dist/index.js
2 | var __create = Object.create;
3 | var __defProp = Object.defineProperty;
4 | var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5 | var __getOwnPropNames = Object.getOwnPropertyNames;
6 | var __getProtoOf = Object.getPrototypeOf;
7 | var __hasOwnProp = Object.prototype.hasOwnProperty;
8 | var __esm = (fn, res) => function __init() {
9 | return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
10 | };
11 | var __commonJS = (cb, mod) => function __require() {
12 | return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
13 | };
14 | var __copyProps = (to, from, except, desc) => {
15 | if (from && typeof from === "object" || typeof from === "function") {
16 | for (let key of __getOwnPropNames(from))
17 | if (!__hasOwnProp.call(to, key) && key !== except)
18 | __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
19 | }
20 | return to;
21 | };
22 | var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
23 | // If the importer is in node compatibility mode or this is not an ESM
24 | // file that has been converted to a CommonJS file using a Babel-
25 | // compatible transform (i.e. "__esModule" has not been set), then set
26 | // "default" to the CommonJS "module.exports" for node compatibility.
27 | isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
28 | mod
29 | ));
30 | var init_esm_shims = __esm({
31 | "../../node_modules/.pnpm/[email protected]_@[email protected]_@[email protected][email protected][email protected]_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js"() {
32 | "use strict";
33 | }
34 | });
35 | var require_rfdc = __commonJS({
36 | "../../node_modules/.pnpm/[email protected]/node_modules/rfdc/index.js"(exports, module) {
37 | "use strict";
38 | init_esm_shims();
39 | module.exports = rfdc2;
40 | function copyBuffer(cur) {
41 | if (cur instanceof Buffer) {
42 | return Buffer.from(cur);
43 | }
44 | return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
45 | }
46 | function rfdc2(opts) {
47 | opts = opts || {};
48 | if (opts.circles) return rfdcCircles(opts);
49 | const constructorHandlers = /* @__PURE__ */ new Map();
50 | constructorHandlers.set(Date, (o) => new Date(o));
51 | constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
52 | constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
53 | if (opts.constructorHandlers) {
54 | for (const handler2 of opts.constructorHandlers) {
55 | constructorHandlers.set(handler2[0], handler2[1]);
56 | }
57 | }
58 | let handler = null;
59 | return opts.proto ? cloneProto : clone;
60 | function cloneArray(a, fn) {
61 | const keys = Object.keys(a);
62 | const a2 = new Array(keys.length);
63 | for (let i = 0; i < keys.length; i++) {
64 | const k = keys[i];
65 | const cur = a[k];
66 | if (typeof cur !== "object" || cur === null) {
67 | a2[k] = cur;
68 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
69 | a2[k] = handler(cur, fn);
70 | } else if (ArrayBuffer.isView(cur)) {
71 | a2[k] = copyBuffer(cur);
72 | } else {
73 | a2[k] = fn(cur);
74 | }
75 | }
76 | return a2;
77 | }
78 | function clone(o) {
79 | if (typeof o !== "object" || o === null) return o;
80 | if (Array.isArray(o)) return cloneArray(o, clone);
81 | if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
82 | return handler(o, clone);
83 | }
84 | const o2 = {};
85 | for (const k in o) {
86 | if (Object.hasOwnProperty.call(o, k) === false) continue;
87 | const cur = o[k];
88 | if (typeof cur !== "object" || cur === null) {
89 | o2[k] = cur;
90 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
91 | o2[k] = handler(cur, clone);
92 | } else if (ArrayBuffer.isView(cur)) {
93 | o2[k] = copyBuffer(cur);
94 | } else {
95 | o2[k] = clone(cur);
96 | }
97 | }
98 | return o2;
99 | }
100 | function cloneProto(o) {
101 | if (typeof o !== "object" || o === null) return o;
102 | if (Array.isArray(o)) return cloneArray(o, cloneProto);
103 | if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
104 | return handler(o, cloneProto);
105 | }
106 | const o2 = {};
107 | for (const k in o) {
108 | const cur = o[k];
109 | if (typeof cur !== "object" || cur === null) {
110 | o2[k] = cur;
111 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
112 | o2[k] = handler(cur, cloneProto);
113 | } else if (ArrayBuffer.isView(cur)) {
114 | o2[k] = copyBuffer(cur);
115 | } else {
116 | o2[k] = cloneProto(cur);
117 | }
118 | }
119 | return o2;
120 | }
121 | }
122 | function rfdcCircles(opts) {
123 | const refs = [];
124 | const refsNew = [];
125 | const constructorHandlers = /* @__PURE__ */ new Map();
126 | constructorHandlers.set(Date, (o) => new Date(o));
127 | constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
128 | constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
129 | if (opts.constructorHandlers) {
130 | for (const handler2 of opts.constructorHandlers) {
131 | constructorHandlers.set(handler2[0], handler2[1]);
132 | }
133 | }
134 | let handler = null;
135 | return opts.proto ? cloneProto : clone;
136 | function cloneArray(a, fn) {
137 | const keys = Object.keys(a);
138 | const a2 = new Array(keys.length);
139 | for (let i = 0; i < keys.length; i++) {
140 | const k = keys[i];
141 | const cur = a[k];
142 | if (typeof cur !== "object" || cur === null) {
143 | a2[k] = cur;
144 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
145 | a2[k] = handler(cur, fn);
146 | } else if (ArrayBuffer.isView(cur)) {
147 | a2[k] = copyBuffer(cur);
148 | } else {
149 | const index = refs.indexOf(cur);
150 | if (index !== -1) {
151 | a2[k] = refsNew[index];
152 | } else {
153 | a2[k] = fn(cur);
154 | }
155 | }
156 | }
157 | return a2;
158 | }
159 | function clone(o) {
160 | if (typeof o !== "object" || o === null) return o;
161 | if (Array.isArray(o)) return cloneArray(o, clone);
162 | if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
163 | return handler(o, clone);
164 | }
165 | const o2 = {};
166 | refs.push(o);
167 | refsNew.push(o2);
168 | for (const k in o) {
169 | if (Object.hasOwnProperty.call(o, k) === false) continue;
170 | const cur = o[k];
171 | if (typeof cur !== "object" || cur === null) {
172 | o2[k] = cur;
173 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
174 | o2[k] = handler(cur, clone);
175 | } else if (ArrayBuffer.isView(cur)) {
176 | o2[k] = copyBuffer(cur);
177 | } else {
178 | const i = refs.indexOf(cur);
179 | if (i !== -1) {
180 | o2[k] = refsNew[i];
181 | } else {
182 | o2[k] = clone(cur);
183 | }
184 | }
185 | }
186 | refs.pop();
187 | refsNew.pop();
188 | return o2;
189 | }
190 | function cloneProto(o) {
191 | if (typeof o !== "object" || o === null) return o;
192 | if (Array.isArray(o)) return cloneArray(o, cloneProto);
193 | if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
194 | return handler(o, cloneProto);
195 | }
196 | const o2 = {};
197 | refs.push(o);
198 | refsNew.push(o2);
199 | for (const k in o) {
200 | const cur = o[k];
201 | if (typeof cur !== "object" || cur === null) {
202 | o2[k] = cur;
203 | } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
204 | o2[k] = handler(cur, cloneProto);
205 | } else if (ArrayBuffer.isView(cur)) {
206 | o2[k] = copyBuffer(cur);
207 | } else {
208 | const i = refs.indexOf(cur);
209 | if (i !== -1) {
210 | o2[k] = refsNew[i];
211 | } else {
212 | o2[k] = cloneProto(cur);
213 | }
214 | }
215 | }
216 | refs.pop();
217 | refsNew.pop();
218 | return o2;
219 | }
220 | }
221 | }
222 | });
223 | init_esm_shims();
224 | init_esm_shims();
225 | init_esm_shims();
226 | var isBrowser = typeof navigator !== "undefined";
227 | var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
228 | var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
229 | var isInIframe = isBrowser && target.self !== target.top;
230 | var _a;
231 | var isInElectron = typeof navigator !== "undefined" && ((_a = navigator.userAgent) == null ? void 0 : _a.toLowerCase().includes("electron"));
232 | var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
233 | init_esm_shims();
234 | var import_rfdc = __toESM(require_rfdc(), 1);
235 | var classifyRE = /(?:^|[-_/])(\w)/g;
236 | function toUpper(_, c) {
237 | return c ? c.toUpperCase() : "";
238 | }
239 | function classify(str) {
240 | return str && `${str}`.replace(classifyRE, toUpper);
241 | }
242 | function basename(filename, ext) {
243 | let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
244 | if (normalizedFilename.endsWith(`index${ext}`)) {
245 | normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
246 | }
247 | const lastSlashIndex = normalizedFilename.lastIndexOf("/");
248 | const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
249 | if (ext) {
250 | const extIndex = baseNameWithExt.lastIndexOf(ext);
251 | return baseNameWithExt.substring(0, extIndex);
252 | }
253 | return "";
254 | }
255 | var HTTP_URL_RE = /^https?:\/\//;
256 | function isUrlString(str) {
257 | return str.startsWith("/") || HTTP_URL_RE.test(str);
258 | }
259 | var deepClone = (0, import_rfdc.default)({ circles: true });
260 |
261 | // node_modules/perfect-debounce/dist/index.mjs
262 | var DEBOUNCE_DEFAULTS = {
263 | trailing: true
264 | };
265 | function debounce(fn, wait = 25, options = {}) {
266 | options = { ...DEBOUNCE_DEFAULTS, ...options };
267 | if (!Number.isFinite(wait)) {
268 | throw new TypeError("Expected `wait` to be a finite number");
269 | }
270 | let leadingValue;
271 | let timeout;
272 | let resolveList = [];
273 | let currentPromise;
274 | let trailingArgs;
275 | const applyFn = (_this, args) => {
276 | currentPromise = _applyPromised(fn, _this, args);
277 | currentPromise.finally(() => {
278 | currentPromise = null;
279 | if (options.trailing && trailingArgs && !timeout) {
280 | const promise = applyFn(_this, trailingArgs);
281 | trailingArgs = null;
282 | return promise;
283 | }
284 | });
285 | return currentPromise;
286 | };
287 | return function(...args) {
288 | if (currentPromise) {
289 | if (options.trailing) {
290 | trailingArgs = args;
291 | }
292 | return currentPromise;
293 | }
294 | return new Promise((resolve) => {
295 | const shouldCallNow = !timeout && options.leading;
296 | clearTimeout(timeout);
297 | timeout = setTimeout(() => {
298 | timeout = null;
299 | const promise = options.leading ? leadingValue : applyFn(this, args);
300 | for (const _resolve of resolveList) {
301 | _resolve(promise);
302 | }
303 | resolveList = [];
304 | }, wait);
305 | if (shouldCallNow) {
306 | leadingValue = applyFn(this, args);
307 | resolve(leadingValue);
308 | } else {
309 | resolveList.push(resolve);
310 | }
311 | });
312 | };
313 | }
314 | async function _applyPromised(fn, _this, args) {
315 | return await fn.apply(_this, args);
316 | }
317 |
318 | // node_modules/hookable/dist/index.mjs
319 | function flatHooks(configHooks, hooks2 = {}, parentName) {
320 | for (const key in configHooks) {
321 | const subHook = configHooks[key];
322 | const name = parentName ? `${parentName}:${key}` : key;
323 | if (typeof subHook === "object" && subHook !== null) {
324 | flatHooks(subHook, hooks2, name);
325 | } else if (typeof subHook === "function") {
326 | hooks2[name] = subHook;
327 | }
328 | }
329 | return hooks2;
330 | }
331 | var defaultTask = { run: (function_) => function_() };
332 | var _createTask = () => defaultTask;
333 | var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
334 | function serialTaskCaller(hooks2, args) {
335 | const name = args.shift();
336 | const task = createTask(name);
337 | return hooks2.reduce(
338 | (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
339 | Promise.resolve()
340 | );
341 | }
342 | function parallelTaskCaller(hooks2, args) {
343 | const name = args.shift();
344 | const task = createTask(name);
345 | return Promise.all(hooks2.map((hook2) => task.run(() => hook2(...args))));
346 | }
347 | function callEachWith(callbacks, arg0) {
348 | for (const callback of [...callbacks]) {
349 | callback(arg0);
350 | }
351 | }
352 | var Hookable = class {
353 | constructor() {
354 | this._hooks = {};
355 | this._before = void 0;
356 | this._after = void 0;
357 | this._deprecatedMessages = void 0;
358 | this._deprecatedHooks = {};
359 | this.hook = this.hook.bind(this);
360 | this.callHook = this.callHook.bind(this);
361 | this.callHookWith = this.callHookWith.bind(this);
362 | }
363 | hook(name, function_, options = {}) {
364 | if (!name || typeof function_ !== "function") {
365 | return () => {
366 | };
367 | }
368 | const originalName = name;
369 | let dep;
370 | while (this._deprecatedHooks[name]) {
371 | dep = this._deprecatedHooks[name];
372 | name = dep.to;
373 | }
374 | if (dep && !options.allowDeprecated) {
375 | let message = dep.message;
376 | if (!message) {
377 | message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
378 | }
379 | if (!this._deprecatedMessages) {
380 | this._deprecatedMessages = /* @__PURE__ */ new Set();
381 | }
382 | if (!this._deprecatedMessages.has(message)) {
383 | console.warn(message);
384 | this._deprecatedMessages.add(message);
385 | }
386 | }
387 | if (!function_.name) {
388 | try {
389 | Object.defineProperty(function_, "name", {
390 | get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
391 | configurable: true
392 | });
393 | } catch {
394 | }
395 | }
396 | this._hooks[name] = this._hooks[name] || [];
397 | this._hooks[name].push(function_);
398 | return () => {
399 | if (function_) {
400 | this.removeHook(name, function_);
401 | function_ = void 0;
402 | }
403 | };
404 | }
405 | hookOnce(name, function_) {
406 | let _unreg;
407 | let _function = (...arguments_) => {
408 | if (typeof _unreg === "function") {
409 | _unreg();
410 | }
411 | _unreg = void 0;
412 | _function = void 0;
413 | return function_(...arguments_);
414 | };
415 | _unreg = this.hook(name, _function);
416 | return _unreg;
417 | }
418 | removeHook(name, function_) {
419 | if (this._hooks[name]) {
420 | const index = this._hooks[name].indexOf(function_);
421 | if (index !== -1) {
422 | this._hooks[name].splice(index, 1);
423 | }
424 | if (this._hooks[name].length === 0) {
425 | delete this._hooks[name];
426 | }
427 | }
428 | }
429 | deprecateHook(name, deprecated) {
430 | this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
431 | const _hooks = this._hooks[name] || [];
432 | delete this._hooks[name];
433 | for (const hook2 of _hooks) {
434 | this.hook(name, hook2);
435 | }
436 | }
437 | deprecateHooks(deprecatedHooks) {
438 | Object.assign(this._deprecatedHooks, deprecatedHooks);
439 | for (const name in deprecatedHooks) {
440 | this.deprecateHook(name, deprecatedHooks[name]);
441 | }
442 | }
443 | addHooks(configHooks) {
444 | const hooks2 = flatHooks(configHooks);
445 | const removeFns = Object.keys(hooks2).map(
446 | (key) => this.hook(key, hooks2[key])
447 | );
448 | return () => {
449 | for (const unreg of removeFns.splice(0, removeFns.length)) {
450 | unreg();
451 | }
452 | };
453 | }
454 | removeHooks(configHooks) {
455 | const hooks2 = flatHooks(configHooks);
456 | for (const key in hooks2) {
457 | this.removeHook(key, hooks2[key]);
458 | }
459 | }
460 | removeAllHooks() {
461 | for (const key in this._hooks) {
462 | delete this._hooks[key];
463 | }
464 | }
465 | callHook(name, ...arguments_) {
466 | arguments_.unshift(name);
467 | return this.callHookWith(serialTaskCaller, name, ...arguments_);
468 | }
469 | callHookParallel(name, ...arguments_) {
470 | arguments_.unshift(name);
471 | return this.callHookWith(parallelTaskCaller, name, ...arguments_);
472 | }
473 | callHookWith(caller, name, ...arguments_) {
474 | const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
475 | if (this._before) {
476 | callEachWith(this._before, event);
477 | }
478 | const result = caller(
479 | name in this._hooks ? [...this._hooks[name]] : [],
480 | arguments_
481 | );
482 | if (result instanceof Promise) {
483 | return result.finally(() => {
484 | if (this._after && event) {
485 | callEachWith(this._after, event);
486 | }
487 | });
488 | }
489 | if (this._after && event) {
490 | callEachWith(this._after, event);
491 | }
492 | return result;
493 | }
494 | beforeEach(function_) {
495 | this._before = this._before || [];
496 | this._before.push(function_);
497 | return () => {
498 | if (this._before !== void 0) {
499 | const index = this._before.indexOf(function_);
500 | if (index !== -1) {
501 | this._before.splice(index, 1);
502 | }
503 | }
504 | };
505 | }
506 | afterEach(function_) {
507 | this._after = this._after || [];
508 | this._after.push(function_);
509 | return () => {
510 | if (this._after !== void 0) {
511 | const index = this._after.indexOf(function_);
512 | if (index !== -1) {
513 | this._after.splice(index, 1);
514 | }
515 | }
516 | };
517 | }
518 | };
519 | function createHooks() {
520 | return new Hookable();
521 | }
522 |
523 | // node_modules/birpc/dist/index.mjs
524 | var { clearTimeout: clearTimeout2, setTimeout: setTimeout2 } = globalThis;
525 | var random = Math.random.bind(Math);
526 |
527 | // node_modules/@vue/devtools-kit/dist/index.js
528 | var __create2 = Object.create;
529 | var __defProp2 = Object.defineProperty;
530 | var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
531 | var __getOwnPropNames2 = Object.getOwnPropertyNames;
532 | var __getProtoOf2 = Object.getPrototypeOf;
533 | var __hasOwnProp2 = Object.prototype.hasOwnProperty;
534 | var __esm2 = (fn, res) => function __init() {
535 | return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
536 | };
537 | var __commonJS2 = (cb, mod) => function __require() {
538 | return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
539 | };
540 | var __copyProps2 = (to, from, except, desc) => {
541 | if (from && typeof from === "object" || typeof from === "function") {
542 | for (let key of __getOwnPropNames2(from))
543 | if (!__hasOwnProp2.call(to, key) && key !== except)
544 | __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
545 | }
546 | return to;
547 | };
548 | var __toESM2 = (mod, isNodeMode, target22) => (target22 = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
549 | // If the importer is in node compatibility mode or this is not an ESM
550 | // file that has been converted to a CommonJS file using a Babel-
551 | // compatible transform (i.e. "__esModule" has not been set), then set
552 | // "default" to the CommonJS "module.exports" for node compatibility.
553 | isNodeMode || !mod || !mod.__esModule ? __defProp2(target22, "default", { value: mod, enumerable: true }) : target22,
554 | mod
555 | ));
556 | var init_esm_shims2 = __esm2({
557 | "../../node_modules/.pnpm/[email protected]_@[email protected]_@[email protected][email protected][email protected]_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js"() {
558 | "use strict";
559 | }
560 | });
561 | var require_speakingurl = __commonJS2({
562 | "../../node_modules/.pnpm/[email protected]/node_modules/speakingurl/lib/speakingurl.js"(exports, module) {
563 | "use strict";
564 | init_esm_shims2();
565 | (function(root) {
566 | "use strict";
567 | var charMap = {
568 | // latin
569 | "À": "A",
570 | "Á": "A",
571 | "Â": "A",
572 | "Ã": "A",
573 | "Ä": "Ae",
574 | "Å": "A",
575 | "Æ": "AE",
576 | "Ç": "C",
577 | "È": "E",
578 | "É": "E",
579 | "Ê": "E",
580 | "Ë": "E",
581 | "Ì": "I",
582 | "Í": "I",
583 | "Î": "I",
584 | "Ï": "I",
585 | "Ð": "D",
586 | "Ñ": "N",
587 | "Ò": "O",
588 | "Ó": "O",
589 | "Ô": "O",
590 | "Õ": "O",
591 | "Ö": "Oe",
592 | "Ő": "O",
593 | "Ø": "O",
594 | "Ù": "U",
595 | "Ú": "U",
596 | "Û": "U",
597 | "Ü": "Ue",
598 | "Ű": "U",
599 | "Ý": "Y",
600 | "Þ": "TH",
601 | "ß": "ss",
602 | "à": "a",
603 | "á": "a",
604 | "â": "a",
605 | "ã": "a",
606 | "ä": "ae",
607 | "å": "a",
608 | "æ": "ae",
609 | "ç": "c",
610 | "è": "e",
611 | "é": "e",
612 | "ê": "e",
613 | "ë": "e",
614 | "ì": "i",
615 | "í": "i",
616 | "î": "i",
617 | "ï": "i",
618 | "ð": "d",
619 | "ñ": "n",
620 | "ò": "o",
621 | "ó": "o",
622 | "ô": "o",
623 | "õ": "o",
624 | "ö": "oe",
625 | "ő": "o",
626 | "ø": "o",
627 | "ù": "u",
628 | "ú": "u",
629 | "û": "u",
630 | "ü": "ue",
631 | "ű": "u",
632 | "ý": "y",
633 | "þ": "th",
634 | "ÿ": "y",
635 | "ẞ": "SS",
636 | // language specific
637 | // Arabic
638 | "ا": "a",
639 | "أ": "a",
640 | "إ": "i",
641 | "آ": "aa",
642 | "ؤ": "u",
643 | "ئ": "e",
644 | "ء": "a",
645 | "ب": "b",
646 | "ت": "t",
647 | "ث": "th",
648 | "ج": "j",
649 | "ح": "h",
650 | "خ": "kh",
651 | "د": "d",
652 | "ذ": "th",
653 | "ر": "r",
654 | "ز": "z",
655 | "س": "s",
656 | "ش": "sh",
657 | "ص": "s",
658 | "ض": "dh",
659 | "ط": "t",
660 | "ظ": "z",
661 | "ع": "a",
662 | "غ": "gh",
663 | "ف": "f",
664 | "ق": "q",
665 | "ك": "k",
666 | "ل": "l",
667 | "م": "m",
668 | "ن": "n",
669 | "ه": "h",
670 | "و": "w",
671 | "ي": "y",
672 | "ى": "a",
673 | "ة": "h",
674 | "ﻻ": "la",
675 | "ﻷ": "laa",
676 | "ﻹ": "lai",
677 | "ﻵ": "laa",
678 | // Persian additional characters than Arabic
679 | "گ": "g",
680 | "چ": "ch",
681 | "پ": "p",
682 | "ژ": "zh",
683 | "ک": "k",
684 | "ی": "y",
685 | // Arabic diactrics
686 | "َ": "a",
687 | "ً": "an",
688 | "ِ": "e",
689 | "ٍ": "en",
690 | "ُ": "u",
691 | "ٌ": "on",
692 | "ْ": "",
693 | // Arabic numbers
694 | "٠": "0",
695 | "١": "1",
696 | "٢": "2",
697 | "٣": "3",
698 | "٤": "4",
699 | "٥": "5",
700 | "٦": "6",
701 | "٧": "7",
702 | "٨": "8",
703 | "٩": "9",
704 | // Persian numbers
705 | "۰": "0",
706 | "۱": "1",
707 | "۲": "2",
708 | "۳": "3",
709 | "۴": "4",
710 | "۵": "5",
711 | "۶": "6",
712 | "۷": "7",
713 | "۸": "8",
714 | "۹": "9",
715 | // Burmese consonants
716 | "က": "k",
717 | "ခ": "kh",
718 | "ဂ": "g",
719 | "ဃ": "ga",
720 | "င": "ng",
721 | "စ": "s",
722 | "ဆ": "sa",
723 | "ဇ": "z",
724 | "စျ": "za",
725 | "ည": "ny",
726 | "ဋ": "t",
727 | "ဌ": "ta",
728 | "ဍ": "d",
729 | "ဎ": "da",
730 | "ဏ": "na",
731 | "တ": "t",
732 | "ထ": "ta",
733 | "ဒ": "d",
734 | "ဓ": "da",
735 | "န": "n",
736 | "ပ": "p",
737 | "ဖ": "pa",
738 | "ဗ": "b",
739 | "ဘ": "ba",
740 | "မ": "m",
741 | "ယ": "y",
742 | "ရ": "ya",
743 | "လ": "l",
744 | "ဝ": "w",
745 | "သ": "th",
746 | "ဟ": "h",
747 | "ဠ": "la",
748 | "အ": "a",
749 | // consonant character combos
750 | "ြ": "y",
751 | "ျ": "ya",
752 | "ွ": "w",
753 | "ြွ": "yw",
754 | "ျွ": "ywa",
755 | "ှ": "h",
756 | // independent vowels
757 | "ဧ": "e",
758 | "၏": "-e",
759 | "ဣ": "i",
760 | "ဤ": "-i",
761 | "ဉ": "u",
762 | "ဦ": "-u",
763 | "ဩ": "aw",
764 | "သြော": "aw",
765 | "ဪ": "aw",
766 | // numbers
767 | "၀": "0",
768 | "၁": "1",
769 | "၂": "2",
770 | "၃": "3",
771 | "၄": "4",
772 | "၅": "5",
773 | "၆": "6",
774 | "၇": "7",
775 | "၈": "8",
776 | "၉": "9",
777 | // virama and tone marks which are silent in transliteration
778 | "္": "",
779 | "့": "",
780 | "း": "",
781 | // Czech
782 | "č": "c",
783 | "ď": "d",
784 | "ě": "e",
785 | "ň": "n",
786 | "ř": "r",
787 | "š": "s",
788 | "ť": "t",
789 | "ů": "u",
790 | "ž": "z",
791 | "Č": "C",
792 | "Ď": "D",
793 | "Ě": "E",
794 | "Ň": "N",
795 | "Ř": "R",
796 | "Š": "S",
797 | "Ť": "T",
798 | "Ů": "U",
799 | "Ž": "Z",
800 | // Dhivehi
801 | "ހ": "h",
802 | "ށ": "sh",
803 | "ނ": "n",
804 | "ރ": "r",
805 | "ބ": "b",
806 | "ޅ": "lh",
807 | "ކ": "k",
808 | "އ": "a",
809 | "ވ": "v",
810 | "މ": "m",
811 | "ފ": "f",
812 | "ދ": "dh",
813 | "ތ": "th",
814 | "ލ": "l",
815 | "ގ": "g",
816 | "ޏ": "gn",
817 | "ސ": "s",
818 | "ޑ": "d",
819 | "ޒ": "z",
820 | "ޓ": "t",
821 | "ޔ": "y",
822 | "ޕ": "p",
823 | "ޖ": "j",
824 | "ޗ": "ch",
825 | "ޘ": "tt",
826 | "ޙ": "hh",
827 | "ޚ": "kh",
828 | "ޛ": "th",
829 | "ޜ": "z",
830 | "ޝ": "sh",
831 | "ޞ": "s",
832 | "ޟ": "d",
833 | "ޠ": "t",
834 | "ޡ": "z",
835 | "ޢ": "a",
836 | "ޣ": "gh",
837 | "ޤ": "q",
838 | "ޥ": "w",
839 | "ަ": "a",
840 | "ާ": "aa",
841 | "ި": "i",
842 | "ީ": "ee",
843 | "ު": "u",
844 | "ޫ": "oo",
845 | "ެ": "e",
846 | "ޭ": "ey",
847 | "ޮ": "o",
848 | "ޯ": "oa",
849 | "ް": "",
850 | // Georgian https://en.wikipedia.org/wiki/Romanization_of_Georgian
851 | // National system (2002)
852 | "ა": "a",
853 | "ბ": "b",
854 | "გ": "g",
855 | "დ": "d",
856 | "ე": "e",
857 | "ვ": "v",
858 | "ზ": "z",
859 | "თ": "t",
860 | "ი": "i",
861 | "კ": "k",
862 | "ლ": "l",
863 | "მ": "m",
864 | "ნ": "n",
865 | "ო": "o",
866 | "პ": "p",
867 | "ჟ": "zh",
868 | "რ": "r",
869 | "ს": "s",
870 | "ტ": "t",
871 | "უ": "u",
872 | "ფ": "p",
873 | "ქ": "k",
874 | "ღ": "gh",
875 | "ყ": "q",
876 | "შ": "sh",
877 | "ჩ": "ch",
878 | "ც": "ts",
879 | "ძ": "dz",
880 | "წ": "ts",
881 | "ჭ": "ch",
882 | "ხ": "kh",
883 | "ჯ": "j",
884 | "ჰ": "h",
885 | // Greek
886 | "α": "a",
887 | "β": "v",
888 | "γ": "g",
889 | "δ": "d",
890 | "ε": "e",
891 | "ζ": "z",
892 | "η": "i",
893 | "θ": "th",
894 | "ι": "i",
895 | "κ": "k",
896 | "λ": "l",
897 | "μ": "m",
898 | "ν": "n",
899 | "ξ": "ks",
900 | "ο": "o",
901 | "π": "p",
902 | "ρ": "r",
903 | "σ": "s",
904 | "τ": "t",
905 | "υ": "y",
906 | "φ": "f",
907 | "χ": "x",
908 | "ψ": "ps",
909 | "ω": "o",
910 | "ά": "a",
911 | "έ": "e",
912 | "ί": "i",
913 | "ό": "o",
914 | "ύ": "y",
915 | "ή": "i",
916 | "ώ": "o",
917 | "ς": "s",
918 | "ϊ": "i",
919 | "ΰ": "y",
920 | "ϋ": "y",
921 | "ΐ": "i",
922 | "Α": "A",
923 | "Β": "B",
924 | "Γ": "G",
925 | "Δ": "D",
926 | "Ε": "E",
927 | "Ζ": "Z",
928 | "Η": "I",
929 | "Θ": "TH",
930 | "Ι": "I",
931 | "Κ": "K",
932 | "Λ": "L",
933 | "Μ": "M",
934 | "Ν": "N",
935 | "Ξ": "KS",
936 | "Ο": "O",
937 | "Π": "P",
938 | "Ρ": "R",
939 | "Σ": "S",
940 | "Τ": "T",
941 | "Υ": "Y",
942 | "Φ": "F",
943 | "Χ": "X",
944 | "Ψ": "PS",
945 | "Ω": "O",
946 | "Ά": "A",
947 | "Έ": "E",
948 | "Ί": "I",
949 | "Ό": "O",
950 | "Ύ": "Y",
951 | "Ή": "I",
952 | "Ώ": "O",
953 | "Ϊ": "I",
954 | "Ϋ": "Y",
955 | // Latvian
956 | "ā": "a",
957 | // 'č': 'c', // duplicate
958 | "ē": "e",
959 | "ģ": "g",
960 | "ī": "i",
961 | "ķ": "k",
962 | "ļ": "l",
963 | "ņ": "n",
964 | // 'š': 's', // duplicate
965 | "ū": "u",
966 | // 'ž': 'z', // duplicate
967 | "Ā": "A",
968 | // 'Č': 'C', // duplicate
969 | "Ē": "E",
970 | "Ģ": "G",
971 | "Ī": "I",
972 | "Ķ": "k",
973 | "Ļ": "L",
974 | "Ņ": "N",
975 | // 'Š': 'S', // duplicate
976 | "Ū": "U",
977 | // 'Ž': 'Z', // duplicate
978 | // Macedonian
979 | "Ќ": "Kj",
980 | "ќ": "kj",
981 | "Љ": "Lj",
982 | "љ": "lj",
983 | "Њ": "Nj",
984 | "њ": "nj",
985 | "Тс": "Ts",
986 | "тс": "ts",
987 | // Polish
988 | "ą": "a",
989 | "ć": "c",
990 | "ę": "e",
991 | "ł": "l",
992 | "ń": "n",
993 | // 'ó': 'o', // duplicate
994 | "ś": "s",
995 | "ź": "z",
996 | "ż": "z",
997 | "Ą": "A",
998 | "Ć": "C",
999 | "Ę": "E",
1000 | "Ł": "L",
1001 | "Ń": "N",
1002 | "Ś": "S",
1003 | "Ź": "Z",
1004 | "Ż": "Z",
1005 | // Ukranian
1006 | "Є": "Ye",
1007 | "І": "I",
1008 | "Ї": "Yi",
1009 | "Ґ": "G",
1010 | "є": "ye",
1011 | "і": "i",
1012 | "ї": "yi",
1013 | "ґ": "g",
1014 | // Romanian
1015 | "ă": "a",
1016 | "Ă": "A",
1017 | "ș": "s",
1018 | "Ș": "S",
1019 | // 'ş': 's', // duplicate
1020 | // 'Ş': 'S', // duplicate
1021 | "ț": "t",
1022 | "Ț": "T",
1023 | "ţ": "t",
1024 | "Ţ": "T",
1025 | // Russian https://en.wikipedia.org/wiki/Romanization_of_Russian
1026 | // ICAO
1027 | "а": "a",
1028 | "б": "b",
1029 | "в": "v",
1030 | "г": "g",
1031 | "д": "d",
1032 | "е": "e",
1033 | "ё": "yo",
1034 | "ж": "zh",
1035 | "з": "z",
1036 | "и": "i",
1037 | "й": "i",
1038 | "к": "k",
1039 | "л": "l",
1040 | "м": "m",
1041 | "н": "n",
1042 | "о": "o",
1043 | "п": "p",
1044 | "р": "r",
1045 | "с": "s",
1046 | "т": "t",
1047 | "у": "u",
1048 | "ф": "f",
1049 | "х": "kh",
1050 | "ц": "c",
1051 | "ч": "ch",
1052 | "ш": "sh",
1053 | "щ": "sh",
1054 | "ъ": "",
1055 | "ы": "y",
1056 | "ь": "",
1057 | "э": "e",
1058 | "ю": "yu",
1059 | "я": "ya",
1060 | "А": "A",
1061 | "Б": "B",
1062 | "В": "V",
1063 | "Г": "G",
1064 | "Д": "D",
1065 | "Е": "E",
1066 | "Ё": "Yo",
1067 | "Ж": "Zh",
1068 | "З": "Z",
1069 | "И": "I",
1070 | "Й": "I",
1071 | "К": "K",
1072 | "Л": "L",
1073 | "М": "M",
1074 | "Н": "N",
1075 | "О": "O",
1076 | "П": "P",
1077 | "Р": "R",
1078 | "С": "S",
1079 | "Т": "T",
1080 | "У": "U",
1081 | "Ф": "F",
1082 | "Х": "Kh",
1083 | "Ц": "C",
1084 | "Ч": "Ch",
1085 | "Ш": "Sh",
1086 | "Щ": "Sh",
1087 | "Ъ": "",
1088 | "Ы": "Y",
1089 | "Ь": "",
1090 | "Э": "E",
1091 | "Ю": "Yu",
1092 | "Я": "Ya",
1093 | // Serbian
1094 | "ђ": "dj",
1095 | "ј": "j",
1096 | // 'љ': 'lj', // duplicate
1097 | // 'њ': 'nj', // duplicate
1098 | "ћ": "c",
1099 | "џ": "dz",
1100 | "Ђ": "Dj",
1101 | "Ј": "j",
1102 | // 'Љ': 'Lj', // duplicate
1103 | // 'Њ': 'Nj', // duplicate
1104 | "Ћ": "C",
1105 | "Џ": "Dz",
1106 | // Slovak
1107 | "ľ": "l",
1108 | "ĺ": "l",
1109 | "ŕ": "r",
1110 | "Ľ": "L",
1111 | "Ĺ": "L",
1112 | "Ŕ": "R",
1113 | // Turkish
1114 | "ş": "s",
1115 | "Ş": "S",
1116 | "ı": "i",
1117 | "İ": "I",
1118 | // 'ç': 'c', // duplicate
1119 | // 'Ç': 'C', // duplicate
1120 | // 'ü': 'u', // duplicate, see langCharMap
1121 | // 'Ü': 'U', // duplicate, see langCharMap
1122 | // 'ö': 'o', // duplicate, see langCharMap
1123 | // 'Ö': 'O', // duplicate, see langCharMap
1124 | "ğ": "g",
1125 | "Ğ": "G",
1126 | // Vietnamese
1127 | "ả": "a",
1128 | "Ả": "A",
1129 | "ẳ": "a",
1130 | "Ẳ": "A",
1131 | "ẩ": "a",
1132 | "Ẩ": "A",
1133 | "đ": "d",
1134 | "Đ": "D",
1135 | "ẹ": "e",
1136 | "Ẹ": "E",
1137 | "ẽ": "e",
1138 | "Ẽ": "E",
1139 | "ẻ": "e",
1140 | "Ẻ": "E",
1141 | "ế": "e",
1142 | "Ế": "E",
1143 | "ề": "e",
1144 | "Ề": "E",
1145 | "ệ": "e",
1146 | "Ệ": "E",
1147 | "ễ": "e",
1148 | "Ễ": "E",
1149 | "ể": "e",
1150 | "Ể": "E",
1151 | "ỏ": "o",
1152 | "ọ": "o",
1153 | "Ọ": "o",
1154 | "ố": "o",
1155 | "Ố": "O",
1156 | "ồ": "o",
1157 | "Ồ": "O",
1158 | "ổ": "o",
1159 | "Ổ": "O",
1160 | "ộ": "o",
1161 | "Ộ": "O",
1162 | "ỗ": "o",
1163 | "Ỗ": "O",
1164 | "ơ": "o",
1165 | "Ơ": "O",
1166 | "ớ": "o",
1167 | "Ớ": "O",
1168 | "ờ": "o",
1169 | "Ờ": "O",
1170 | "ợ": "o",
1171 | "Ợ": "O",
1172 | "ỡ": "o",
1173 | "Ỡ": "O",
1174 | "Ở": "o",
1175 | "ở": "o",
1176 | "ị": "i",
1177 | "Ị": "I",
1178 | "ĩ": "i",
1179 | "Ĩ": "I",
1180 | "ỉ": "i",
1181 | "Ỉ": "i",
1182 | "ủ": "u",
1183 | "Ủ": "U",
1184 | "ụ": "u",
1185 | "Ụ": "U",
1186 | "ũ": "u",
1187 | "Ũ": "U",
1188 | "ư": "u",
1189 | "Ư": "U",
1190 | "ứ": "u",
1191 | "Ứ": "U",
1192 | "ừ": "u",
1193 | "Ừ": "U",
1194 | "ự": "u",
1195 | "Ự": "U",
1196 | "ữ": "u",
1197 | "Ữ": "U",
1198 | "ử": "u",
1199 | "Ử": "ư",
1200 | "ỷ": "y",
1201 | "Ỷ": "y",
1202 | "ỳ": "y",
1203 | "Ỳ": "Y",
1204 | "ỵ": "y",
1205 | "Ỵ": "Y",
1206 | "ỹ": "y",
1207 | "Ỹ": "Y",
1208 | "ạ": "a",
1209 | "Ạ": "A",
1210 | "ấ": "a",
1211 | "Ấ": "A",
1212 | "ầ": "a",
1213 | "Ầ": "A",
1214 | "ậ": "a",
1215 | "Ậ": "A",
1216 | "ẫ": "a",
1217 | "Ẫ": "A",
1218 | // 'ă': 'a', // duplicate
1219 | // 'Ă': 'A', // duplicate
1220 | "ắ": "a",
1221 | "Ắ": "A",
1222 | "ằ": "a",
1223 | "Ằ": "A",
1224 | "ặ": "a",
1225 | "Ặ": "A",
1226 | "ẵ": "a",
1227 | "Ẵ": "A",
1228 | "⓪": "0",
1229 | "①": "1",
1230 | "②": "2",
1231 | "③": "3",
1232 | "④": "4",
1233 | "⑤": "5",
1234 | "⑥": "6",
1235 | "⑦": "7",
1236 | "⑧": "8",
1237 | "⑨": "9",
1238 | "⑩": "10",
1239 | "⑪": "11",
1240 | "⑫": "12",
1241 | "⑬": "13",
1242 | "⑭": "14",
1243 | "⑮": "15",
1244 | "⑯": "16",
1245 | "⑰": "17",
1246 | "⑱": "18",
1247 | "⑲": "18",
1248 | "⑳": "18",
1249 | "⓵": "1",
1250 | "⓶": "2",
1251 | "⓷": "3",
1252 | "⓸": "4",
1253 | "⓹": "5",
1254 | "⓺": "6",
1255 | "⓻": "7",
1256 | "⓼": "8",
1257 | "⓽": "9",
1258 | "⓾": "10",
1259 | "⓿": "0",
1260 | "⓫": "11",
1261 | "⓬": "12",
1262 | "⓭": "13",
1263 | "⓮": "14",
1264 | "⓯": "15",
1265 | "⓰": "16",
1266 | "⓱": "17",
1267 | "⓲": "18",
1268 | "⓳": "19",
1269 | "⓴": "20",
1270 | "Ⓐ": "A",
1271 | "Ⓑ": "B",
1272 | "Ⓒ": "C",
1273 | "Ⓓ": "D",
1274 | "Ⓔ": "E",
1275 | "Ⓕ": "F",
1276 | "Ⓖ": "G",
1277 | "Ⓗ": "H",
1278 | "Ⓘ": "I",
1279 | "Ⓙ": "J",
1280 | "Ⓚ": "K",
1281 | "Ⓛ": "L",
1282 | "Ⓜ": "M",
1283 | "Ⓝ": "N",
1284 | "Ⓞ": "O",
1285 | "Ⓟ": "P",
1286 | "Ⓠ": "Q",
1287 | "Ⓡ": "R",
1288 | "Ⓢ": "S",
1289 | "Ⓣ": "T",
1290 | "Ⓤ": "U",
1291 | "Ⓥ": "V",
1292 | "Ⓦ": "W",
1293 | "Ⓧ": "X",
1294 | "Ⓨ": "Y",
1295 | "Ⓩ": "Z",
1296 | "ⓐ": "a",
1297 | "ⓑ": "b",
1298 | "ⓒ": "c",
1299 | "ⓓ": "d",
1300 | "ⓔ": "e",
1301 | "ⓕ": "f",
1302 | "ⓖ": "g",
1303 | "ⓗ": "h",
1304 | "ⓘ": "i",
1305 | "ⓙ": "j",
1306 | "ⓚ": "k",
1307 | "ⓛ": "l",
1308 | "ⓜ": "m",
1309 | "ⓝ": "n",
1310 | "ⓞ": "o",
1311 | "ⓟ": "p",
1312 | "ⓠ": "q",
1313 | "ⓡ": "r",
1314 | "ⓢ": "s",
1315 | "ⓣ": "t",
1316 | "ⓤ": "u",
1317 | "ⓦ": "v",
1318 | "ⓥ": "w",
1319 | "ⓧ": "x",
1320 | "ⓨ": "y",
1321 | "ⓩ": "z",
1322 | // symbols
1323 | "“": '"',
1324 | "”": '"',
1325 | "‘": "'",
1326 | "’": "'",
1327 | "∂": "d",
1328 | "ƒ": "f",
1329 | "™": "(TM)",
1330 | "©": "(C)",
1331 | "œ": "oe",
1332 | "Œ": "OE",
1333 | "®": "(R)",
1334 | "†": "+",
1335 | "℠": "(SM)",
1336 | "…": "...",
1337 | "˚": "o",
1338 | "º": "o",
1339 | "ª": "a",
1340 | "•": "*",
1341 | "၊": ",",
1342 | "။": ".",
1343 | // currency
1344 | "$": "USD",
1345 | "€": "EUR",
1346 | "₢": "BRN",
1347 | "₣": "FRF",
1348 | "£": "GBP",
1349 | "₤": "ITL",
1350 | "₦": "NGN",
1351 | "₧": "ESP",
1352 | "₩": "KRW",
1353 | "₪": "ILS",
1354 | "₫": "VND",
1355 | "₭": "LAK",
1356 | "₮": "MNT",
1357 | "₯": "GRD",
1358 | "₱": "ARS",
1359 | "₲": "PYG",
1360 | "₳": "ARA",
1361 | "₴": "UAH",
1362 | "₵": "GHS",
1363 | "¢": "cent",
1364 | "¥": "CNY",
1365 | "元": "CNY",
1366 | "円": "YEN",
1367 | "﷼": "IRR",
1368 | "₠": "EWE",
1369 | "฿": "THB",
1370 | "₨": "INR",
1371 | "₹": "INR",
1372 | "₰": "PF",
1373 | "₺": "TRY",
1374 | "؋": "AFN",
1375 | "₼": "AZN",
1376 | "лв": "BGN",
1377 | "៛": "KHR",
1378 | "₡": "CRC",
1379 | "₸": "KZT",
1380 | "ден": "MKD",
1381 | "zł": "PLN",
1382 | "₽": "RUB",
1383 | "₾": "GEL"
1384 | };
1385 | var lookAheadCharArray = [
1386 | // burmese
1387 | "်",
1388 | // Dhivehi
1389 | "ް"
1390 | ];
1391 | var diatricMap = {
1392 | // Burmese
1393 | // dependent vowels
1394 | "ာ": "a",
1395 | "ါ": "a",
1396 | "ေ": "e",
1397 | "ဲ": "e",
1398 | "ိ": "i",
1399 | "ီ": "i",
1400 | "ို": "o",
1401 | "ု": "u",
1402 | "ူ": "u",
1403 | "ေါင်": "aung",
1404 | "ော": "aw",
1405 | "ော်": "aw",
1406 | "ေါ": "aw",
1407 | "ေါ်": "aw",
1408 | "်": "်",
1409 | // this is special case but the character will be converted to latin in the code
1410 | "က်": "et",
1411 | "ိုက်": "aik",
1412 | "ောက်": "auk",
1413 | "င်": "in",
1414 | "ိုင်": "aing",
1415 | "ောင်": "aung",
1416 | "စ်": "it",
1417 | "ည်": "i",
1418 | "တ်": "at",
1419 | "ိတ်": "eik",
1420 | "ုတ်": "ok",
1421 | "ွတ်": "ut",
1422 | "ေတ်": "it",
1423 | "ဒ်": "d",
1424 | "ိုဒ်": "ok",
1425 | "ုဒ်": "ait",
1426 | "န်": "an",
1427 | "ာန်": "an",
1428 | "ိန်": "ein",
1429 | "ုန်": "on",
1430 | "ွန်": "un",
1431 | "ပ်": "at",
1432 | "ိပ်": "eik",
1433 | "ုပ်": "ok",
1434 | "ွပ်": "ut",
1435 | "န်ုပ်": "nub",
1436 | "မ်": "an",
1437 | "ိမ်": "ein",
1438 | "ုမ်": "on",
1439 | "ွမ်": "un",
1440 | "ယ်": "e",
1441 | "ိုလ်": "ol",
1442 | "ဉ်": "in",
1443 | "ံ": "an",
1444 | "ိံ": "ein",
1445 | "ုံ": "on",
1446 | // Dhivehi
1447 | "ައް": "ah",
1448 | "ަށް": "ah"
1449 | };
1450 | var langCharMap = {
1451 | "en": {},
1452 | // default language
1453 | "az": {
1454 | // Azerbaijani
1455 | "ç": "c",
1456 | "ə": "e",
1457 | "ğ": "g",
1458 | "ı": "i",
1459 | "ö": "o",
1460 | "ş": "s",
1461 | "ü": "u",
1462 | "Ç": "C",
1463 | "Ə": "E",
1464 | "Ğ": "G",
1465 | "İ": "I",
1466 | "Ö": "O",
1467 | "Ş": "S",
1468 | "Ü": "U"
1469 | },
1470 | "cs": {
1471 | // Czech
1472 | "č": "c",
1473 | "ď": "d",
1474 | "ě": "e",
1475 | "ň": "n",
1476 | "ř": "r",
1477 | "š": "s",
1478 | "ť": "t",
1479 | "ů": "u",
1480 | "ž": "z",
1481 | "Č": "C",
1482 | "Ď": "D",
1483 | "Ě": "E",
1484 | "Ň": "N",
1485 | "Ř": "R",
1486 | "Š": "S",
1487 | "Ť": "T",
1488 | "Ů": "U",
1489 | "Ž": "Z"
1490 | },
1491 | "fi": {
1492 | // Finnish
1493 | // 'å': 'a', duplicate see charMap/latin
1494 | // 'Å': 'A', duplicate see charMap/latin
1495 | "ä": "a",
1496 | // ok
1497 | "Ä": "A",
1498 | // ok
1499 | "ö": "o",
1500 | // ok
1501 | "Ö": "O"
1502 | // ok
1503 | },
1504 | "hu": {
1505 | // Hungarian
1506 | "ä": "a",
1507 | // ok
1508 | "Ä": "A",
1509 | // ok
1510 | // 'á': 'a', duplicate see charMap/latin
1511 | // 'Á': 'A', duplicate see charMap/latin
1512 | "ö": "o",
1513 | // ok
1514 | "Ö": "O",
1515 | // ok
1516 | // 'ő': 'o', duplicate see charMap/latin
1517 | // 'Ő': 'O', duplicate see charMap/latin
1518 | "ü": "u",
1519 | "Ü": "U",
1520 | "ű": "u",
1521 | "Ű": "U"
1522 | },
1523 | "lt": {
1524 | // Lithuanian
1525 | "ą": "a",
1526 | "č": "c",
1527 | "ę": "e",
1528 | "ė": "e",
1529 | "į": "i",
1530 | "š": "s",
1531 | "ų": "u",
1532 | "ū": "u",
1533 | "ž": "z",
1534 | "Ą": "A",
1535 | "Č": "C",
1536 | "Ę": "E",
1537 | "Ė": "E",
1538 | "Į": "I",
1539 | "Š": "S",
1540 | "Ų": "U",
1541 | "Ū": "U"
1542 | },
1543 | "lv": {
1544 | // Latvian
1545 | "ā": "a",
1546 | "č": "c",
1547 | "ē": "e",
1548 | "ģ": "g",
1549 | "ī": "i",
1550 | "ķ": "k",
1551 | "ļ": "l",
1552 | "ņ": "n",
1553 | "š": "s",
1554 | "ū": "u",
1555 | "ž": "z",
1556 | "Ā": "A",
1557 | "Č": "C",
1558 | "Ē": "E",
1559 | "Ģ": "G",
1560 | "Ī": "i",
1561 | "Ķ": "k",
1562 | "Ļ": "L",
1563 | "Ņ": "N",
1564 | "Š": "S",
1565 | "Ū": "u",
1566 | "Ž": "Z"
1567 | },
1568 | "pl": {
1569 | // Polish
1570 | "ą": "a",
1571 | "ć": "c",
1572 | "ę": "e",
1573 | "ł": "l",
1574 | "ń": "n",
1575 | "ó": "o",
1576 | "ś": "s",
1577 | "ź": "z",
1578 | "ż": "z",
1579 | "Ą": "A",
1580 | "Ć": "C",
1581 | "Ę": "e",
1582 | "Ł": "L",
1583 | "Ń": "N",
1584 | "Ó": "O",
1585 | "Ś": "S",
1586 | "Ź": "Z",
1587 | "Ż": "Z"
1588 | },
1589 | "sv": {
1590 | // Swedish
1591 | // 'å': 'a', duplicate see charMap/latin
1592 | // 'Å': 'A', duplicate see charMap/latin
1593 | "ä": "a",
1594 | // ok
1595 | "Ä": "A",
1596 | // ok
1597 | "ö": "o",
1598 | // ok
1599 | "Ö": "O"
1600 | // ok
1601 | },
1602 | "sk": {
1603 | // Slovak
1604 | "ä": "a",
1605 | "Ä": "A"
1606 | },
1607 | "sr": {
1608 | // Serbian
1609 | "љ": "lj",
1610 | "њ": "nj",
1611 | "Љ": "Lj",
1612 | "Њ": "Nj",
1613 | "đ": "dj",
1614 | "Đ": "Dj"
1615 | },
1616 | "tr": {
1617 | // Turkish
1618 | "Ü": "U",
1619 | "Ö": "O",
1620 | "ü": "u",
1621 | "ö": "o"
1622 | }
1623 | };
1624 | var symbolMap = {
1625 | "ar": {
1626 | "∆": "delta",
1627 | "∞": "la-nihaya",
1628 | "♥": "hob",
1629 | "&": "wa",
1630 | "|": "aw",
1631 | "<": "aqal-men",
1632 | ">": "akbar-men",
1633 | "∑": "majmou",
1634 | "¤": "omla"
1635 | },
1636 | "az": {},
1637 | "ca": {
1638 | "∆": "delta",
1639 | "∞": "infinit",
1640 | "♥": "amor",
1641 | "&": "i",
1642 | "|": "o",
1643 | "<": "menys que",
1644 | ">": "mes que",
1645 | "∑": "suma dels",
1646 | "¤": "moneda"
1647 | },
1648 | "cs": {
1649 | "∆": "delta",
1650 | "∞": "nekonecno",
1651 | "♥": "laska",
1652 | "&": "a",
1653 | "|": "nebo",
1654 | "<": "mensi nez",
1655 | ">": "vetsi nez",
1656 | "∑": "soucet",
1657 | "¤": "mena"
1658 | },
1659 | "de": {
1660 | "∆": "delta",
1661 | "∞": "unendlich",
1662 | "♥": "Liebe",
1663 | "&": "und",
1664 | "|": "oder",
1665 | "<": "kleiner als",
1666 | ">": "groesser als",
1667 | "∑": "Summe von",
1668 | "¤": "Waehrung"
1669 | },
1670 | "dv": {
1671 | "∆": "delta",
1672 | "∞": "kolunulaa",
1673 | "♥": "loabi",
1674 | "&": "aai",
1675 | "|": "noonee",
1676 | "<": "ah vure kuda",
1677 | ">": "ah vure bodu",
1678 | "∑": "jumula",
1679 | "¤": "faisaa"
1680 | },
1681 | "en": {
1682 | "∆": "delta",
1683 | "∞": "infinity",
1684 | "♥": "love",
1685 | "&": "and",
1686 | "|": "or",
1687 | "<": "less than",
1688 | ">": "greater than",
1689 | "∑": "sum",
1690 | "¤": "currency"
1691 | },
1692 | "es": {
1693 | "∆": "delta",
1694 | "∞": "infinito",
1695 | "♥": "amor",
1696 | "&": "y",
1697 | "|": "u",
1698 | "<": "menos que",
1699 | ">": "mas que",
1700 | "∑": "suma de los",
1701 | "¤": "moneda"
1702 | },
1703 | "fa": {
1704 | "∆": "delta",
1705 | "∞": "bi-nahayat",
1706 | "♥": "eshgh",
1707 | "&": "va",
1708 | "|": "ya",
1709 | "<": "kamtar-az",
1710 | ">": "bishtar-az",
1711 | "∑": "majmooe",
1712 | "¤": "vahed"
1713 | },
1714 | "fi": {
1715 | "∆": "delta",
1716 | "∞": "aarettomyys",
1717 | "♥": "rakkaus",
1718 | "&": "ja",
1719 | "|": "tai",
1720 | "<": "pienempi kuin",
1721 | ">": "suurempi kuin",
1722 | "∑": "summa",
1723 | "¤": "valuutta"
1724 | },
1725 | "fr": {
1726 | "∆": "delta",
1727 | "∞": "infiniment",
1728 | "♥": "Amour",
1729 | "&": "et",
1730 | "|": "ou",
1731 | "<": "moins que",
1732 | ">": "superieure a",
1733 | "∑": "somme des",
1734 | "¤": "monnaie"
1735 | },
1736 | "ge": {
1737 | "∆": "delta",
1738 | "∞": "usasruloba",
1739 | "♥": "siqvaruli",
1740 | "&": "da",
1741 | "|": "an",
1742 | "<": "naklebi",
1743 | ">": "meti",
1744 | "∑": "jami",
1745 | "¤": "valuta"
1746 | },
1747 | "gr": {},
1748 | "hu": {
1749 | "∆": "delta",
1750 | "∞": "vegtelen",
1751 | "♥": "szerelem",
1752 | "&": "es",
1753 | "|": "vagy",
1754 | "<": "kisebb mint",
1755 | ">": "nagyobb mint",
1756 | "∑": "szumma",
1757 | "¤": "penznem"
1758 | },
1759 | "it": {
1760 | "∆": "delta",
1761 | "∞": "infinito",
1762 | "♥": "amore",
1763 | "&": "e",
1764 | "|": "o",
1765 | "<": "minore di",
1766 | ">": "maggiore di",
1767 | "∑": "somma",
1768 | "¤": "moneta"
1769 | },
1770 | "lt": {
1771 | "∆": "delta",
1772 | "∞": "begalybe",
1773 | "♥": "meile",
1774 | "&": "ir",
1775 | "|": "ar",
1776 | "<": "maziau nei",
1777 | ">": "daugiau nei",
1778 | "∑": "suma",
1779 | "¤": "valiuta"
1780 | },
1781 | "lv": {
1782 | "∆": "delta",
1783 | "∞": "bezgaliba",
1784 | "♥": "milestiba",
1785 | "&": "un",
1786 | "|": "vai",
1787 | "<": "mazak neka",
1788 | ">": "lielaks neka",
1789 | "∑": "summa",
1790 | "¤": "valuta"
1791 | },
1792 | "my": {
1793 | "∆": "kwahkhyaet",
1794 | "∞": "asaonasme",
1795 | "♥": "akhyait",
1796 | "&": "nhin",
1797 | "|": "tho",
1798 | "<": "ngethaw",
1799 | ">": "kyithaw",
1800 | "∑": "paungld",
1801 | "¤": "ngwekye"
1802 | },
1803 | "mk": {},
1804 | "nl": {
1805 | "∆": "delta",
1806 | "∞": "oneindig",
1807 | "♥": "liefde",
1808 | "&": "en",
1809 | "|": "of",
1810 | "<": "kleiner dan",
1811 | ">": "groter dan",
1812 | "∑": "som",
1813 | "¤": "valuta"
1814 | },
1815 | "pl": {
1816 | "∆": "delta",
1817 | "∞": "nieskonczonosc",
1818 | "♥": "milosc",
1819 | "&": "i",
1820 | "|": "lub",
1821 | "<": "mniejsze niz",
1822 | ">": "wieksze niz",
1823 | "∑": "suma",
1824 | "¤": "waluta"
1825 | },
1826 | "pt": {
1827 | "∆": "delta",
1828 | "∞": "infinito",
1829 | "♥": "amor",
1830 | "&": "e",
1831 | "|": "ou",
1832 | "<": "menor que",
1833 | ">": "maior que",
1834 | "∑": "soma",
1835 | "¤": "moeda"
1836 | },
1837 | "ro": {
1838 | "∆": "delta",
1839 | "∞": "infinit",
1840 | "♥": "dragoste",
1841 | "&": "si",
1842 | "|": "sau",
1843 | "<": "mai mic ca",
1844 | ">": "mai mare ca",
1845 | "∑": "suma",
1846 | "¤": "valuta"
1847 | },
1848 | "ru": {
1849 | "∆": "delta",
1850 | "∞": "beskonechno",
1851 | "♥": "lubov",
1852 | "&": "i",
1853 | "|": "ili",
1854 | "<": "menshe",
1855 | ">": "bolshe",
1856 | "∑": "summa",
1857 | "¤": "valjuta"
1858 | },
1859 | "sk": {
1860 | "∆": "delta",
1861 | "∞": "nekonecno",
1862 | "♥": "laska",
1863 | "&": "a",
1864 | "|": "alebo",
1865 | "<": "menej ako",
1866 | ">": "viac ako",
1867 | "∑": "sucet",
1868 | "¤": "mena"
1869 | },
1870 | "sr": {},
1871 | "tr": {
1872 | "∆": "delta",
1873 | "∞": "sonsuzluk",
1874 | "♥": "ask",
1875 | "&": "ve",
1876 | "|": "veya",
1877 | "<": "kucuktur",
1878 | ">": "buyuktur",
1879 | "∑": "toplam",
1880 | "¤": "para birimi"
1881 | },
1882 | "uk": {
1883 | "∆": "delta",
1884 | "∞": "bezkinechnist",
1885 | "♥": "lubov",
1886 | "&": "i",
1887 | "|": "abo",
1888 | "<": "menshe",
1889 | ">": "bilshe",
1890 | "∑": "suma",
1891 | "¤": "valjuta"
1892 | },
1893 | "vn": {
1894 | "∆": "delta",
1895 | "∞": "vo cuc",
1896 | "♥": "yeu",
1897 | "&": "va",
1898 | "|": "hoac",
1899 | "<": "nho hon",
1900 | ">": "lon hon",
1901 | "∑": "tong",
1902 | "¤": "tien te"
1903 | }
1904 | };
1905 | var uricChars = [";", "?", ":", "@", "&", "=", "+", "$", ",", "/"].join("");
1906 | var uricNoSlashChars = [";", "?", ":", "@", "&", "=", "+", "$", ","].join("");
1907 | var markChars = [".", "!", "~", "*", "'", "(", ")"].join("");
1908 | var getSlug = function getSlug2(input, opts) {
1909 | var separator = "-";
1910 | var result = "";
1911 | var diatricString = "";
1912 | var convertSymbols = true;
1913 | var customReplacements = {};
1914 | var maintainCase;
1915 | var titleCase;
1916 | var truncate;
1917 | var uricFlag;
1918 | var uricNoSlashFlag;
1919 | var markFlag;
1920 | var symbol;
1921 | var langChar;
1922 | var lucky;
1923 | var i;
1924 | var ch;
1925 | var l;
1926 | var lastCharWasSymbol;
1927 | var lastCharWasDiatric;
1928 | var allowedChars = "";
1929 | if (typeof input !== "string") {
1930 | return "";
1931 | }
1932 | if (typeof opts === "string") {
1933 | separator = opts;
1934 | }
1935 | symbol = symbolMap.en;
1936 | langChar = langCharMap.en;
1937 | if (typeof opts === "object") {
1938 | maintainCase = opts.maintainCase || false;
1939 | customReplacements = opts.custom && typeof opts.custom === "object" ? opts.custom : customReplacements;
1940 | truncate = +opts.truncate > 1 && opts.truncate || false;
1941 | uricFlag = opts.uric || false;
1942 | uricNoSlashFlag = opts.uricNoSlash || false;
1943 | markFlag = opts.mark || false;
1944 | convertSymbols = opts.symbols === false || opts.lang === false ? false : true;
1945 | separator = opts.separator || separator;
1946 | if (uricFlag) {
1947 | allowedChars += uricChars;
1948 | }
1949 | if (uricNoSlashFlag) {
1950 | allowedChars += uricNoSlashChars;
1951 | }
1952 | if (markFlag) {
1953 | allowedChars += markChars;
1954 | }
1955 | symbol = opts.lang && symbolMap[opts.lang] && convertSymbols ? symbolMap[opts.lang] : convertSymbols ? symbolMap.en : {};
1956 | langChar = opts.lang && langCharMap[opts.lang] ? langCharMap[opts.lang] : opts.lang === false || opts.lang === true ? {} : langCharMap.en;
1957 | if (opts.titleCase && typeof opts.titleCase.length === "number" && Array.prototype.toString.call(opts.titleCase)) {
1958 | opts.titleCase.forEach(function(v) {
1959 | customReplacements[v + ""] = v + "";
1960 | });
1961 | titleCase = true;
1962 | } else {
1963 | titleCase = !!opts.titleCase;
1964 | }
1965 | if (opts.custom && typeof opts.custom.length === "number" && Array.prototype.toString.call(opts.custom)) {
1966 | opts.custom.forEach(function(v) {
1967 | customReplacements[v + ""] = v + "";
1968 | });
1969 | }
1970 | Object.keys(customReplacements).forEach(function(v) {
1971 | var r;
1972 | if (v.length > 1) {
1973 | r = new RegExp("\\b" + escapeChars(v) + "\\b", "gi");
1974 | } else {
1975 | r = new RegExp(escapeChars(v), "gi");
1976 | }
1977 | input = input.replace(r, customReplacements[v]);
1978 | });
1979 | for (ch in customReplacements) {
1980 | allowedChars += ch;
1981 | }
1982 | }
1983 | allowedChars += separator;
1984 | allowedChars = escapeChars(allowedChars);
1985 | input = input.replace(/(^\s+|\s+$)/g, "");
1986 | lastCharWasSymbol = false;
1987 | lastCharWasDiatric = false;
1988 | for (i = 0, l = input.length; i < l; i++) {
1989 | ch = input[i];
1990 | if (isReplacedCustomChar(ch, customReplacements)) {
1991 | lastCharWasSymbol = false;
1992 | } else if (langChar[ch]) {
1993 | ch = lastCharWasSymbol && langChar[ch].match(/[A-Za-z0-9]/) ? " " + langChar[ch] : langChar[ch];
1994 | lastCharWasSymbol = false;
1995 | } else if (ch in charMap) {
1996 | if (i + 1 < l && lookAheadCharArray.indexOf(input[i + 1]) >= 0) {
1997 | diatricString += ch;
1998 | ch = "";
1999 | } else if (lastCharWasDiatric === true) {
2000 | ch = diatricMap[diatricString] + charMap[ch];
2001 | diatricString = "";
2002 | } else {
2003 | ch = lastCharWasSymbol && charMap[ch].match(/[A-Za-z0-9]/) ? " " + charMap[ch] : charMap[ch];
2004 | }
2005 | lastCharWasSymbol = false;
2006 | lastCharWasDiatric = false;
2007 | } else if (ch in diatricMap) {
2008 | diatricString += ch;
2009 | ch = "";
2010 | if (i === l - 1) {
2011 | ch = diatricMap[diatricString];
2012 | }
2013 | lastCharWasDiatric = true;
2014 | } else if (
2015 | // process symbol chars
2016 | symbol[ch] && !(uricFlag && uricChars.indexOf(ch) !== -1) && !(uricNoSlashFlag && uricNoSlashChars.indexOf(ch) !== -1)
2017 | ) {
2018 | ch = lastCharWasSymbol || result.substr(-1).match(/[A-Za-z0-9]/) ? separator + symbol[ch] : symbol[ch];
2019 | ch += input[i + 1] !== void 0 && input[i + 1].match(/[A-Za-z0-9]/) ? separator : "";
2020 | lastCharWasSymbol = true;
2021 | } else {
2022 | if (lastCharWasDiatric === true) {
2023 | ch = diatricMap[diatricString] + ch;
2024 | diatricString = "";
2025 | lastCharWasDiatric = false;
2026 | } else if (lastCharWasSymbol && (/[A-Za-z0-9]/.test(ch) || result.substr(-1).match(/A-Za-z0-9]/))) {
2027 | ch = " " + ch;
2028 | }
2029 | lastCharWasSymbol = false;
2030 | }
2031 | result += ch.replace(new RegExp("[^\\w\\s" + allowedChars + "_-]", "g"), separator);
2032 | }
2033 | if (titleCase) {
2034 | result = result.replace(/(\w)(\S*)/g, function(_, i2, r) {
2035 | var j = i2.toUpperCase() + (r !== null ? r : "");
2036 | return Object.keys(customReplacements).indexOf(j.toLowerCase()) < 0 ? j : j.toLowerCase();
2037 | });
2038 | }
2039 | result = result.replace(/\s+/g, separator).replace(new RegExp("\\" + separator + "+", "g"), separator).replace(new RegExp("(^\\" + separator + "+|\\" + separator + "+$)", "g"), "");
2040 | if (truncate && result.length > truncate) {
2041 | lucky = result.charAt(truncate) === separator;
2042 | result = result.slice(0, truncate);
2043 | if (!lucky) {
2044 | result = result.slice(0, result.lastIndexOf(separator));
2045 | }
2046 | }
2047 | if (!maintainCase && !titleCase) {
2048 | result = result.toLowerCase();
2049 | }
2050 | return result;
2051 | };
2052 | var createSlug = function createSlug2(opts) {
2053 | return function getSlugWithConfig(input) {
2054 | return getSlug(input, opts);
2055 | };
2056 | };
2057 | var escapeChars = function escapeChars2(input) {
2058 | return input.replace(/[-\\^$*+?.()|[\]{}\/]/g, "\\$&");
2059 | };
2060 | var isReplacedCustomChar = function(ch, customReplacements) {
2061 | for (var c in customReplacements) {
2062 | if (customReplacements[c] === ch) {
2063 | return true;
2064 | }
2065 | }
2066 | };
2067 | if (typeof module !== "undefined" && module.exports) {
2068 | module.exports = getSlug;
2069 | module.exports.createSlug = createSlug;
2070 | } else if (typeof define !== "undefined" && define.amd) {
2071 | define([], function() {
2072 | return getSlug;
2073 | });
2074 | } else {
2075 | try {
2076 | if (root.getSlug || root.createSlug) {
2077 | throw "speakingurl: globals exists /(getSlug|createSlug)/";
2078 | } else {
2079 | root.getSlug = getSlug;
2080 | root.createSlug = createSlug;
2081 | }
2082 | } catch (e) {
2083 | }
2084 | }
2085 | })(exports);
2086 | }
2087 | });
2088 | var require_speakingurl2 = __commonJS2({
2089 | "../../node_modules/.pnpm/[email protected]/node_modules/speakingurl/index.js"(exports, module) {
2090 | "use strict";
2091 | init_esm_shims2();
2092 | module.exports = require_speakingurl();
2093 | }
2094 | });
2095 | init_esm_shims2();
2096 | init_esm_shims2();
2097 | init_esm_shims2();
2098 | init_esm_shims2();
2099 | init_esm_shims2();
2100 | init_esm_shims2();
2101 | init_esm_shims2();
2102 | init_esm_shims2();
2103 | function getComponentTypeName(options) {
2104 | var _a25;
2105 | const name = options.name || options._componentTag || options.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ || options.__name;
2106 | if (name === "index" && ((_a25 = options.__file) == null ? void 0 : _a25.endsWith("index.vue"))) {
2107 | return "";
2108 | }
2109 | return name;
2110 | }
2111 | function getComponentFileName(options) {
2112 | const file = options.__file;
2113 | if (file)
2114 | return classify(basename(file, ".vue"));
2115 | }
2116 | function saveComponentGussedName(instance, name) {
2117 | instance.type.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ = name;
2118 | return name;
2119 | }
2120 | function getAppRecord(instance) {
2121 | if (instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__)
2122 | return instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
2123 | else if (instance.root)
2124 | return instance.appContext.app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
2125 | }
2126 | function isFragment(instance) {
2127 | var _a25, _b25;
2128 | const subTreeType = (_a25 = instance.subTree) == null ? void 0 : _a25.type;
2129 | const appRecord = getAppRecord(instance);
2130 | if (appRecord) {
2131 | return ((_b25 = appRecord == null ? void 0 : appRecord.types) == null ? void 0 : _b25.Fragment) === subTreeType;
2132 | }
2133 | return false;
2134 | }
2135 | function getInstanceName(instance) {
2136 | var _a25, _b25, _c;
2137 | const name = getComponentTypeName((instance == null ? void 0 : instance.type) || {});
2138 | if (name)
2139 | return name;
2140 | if ((instance == null ? void 0 : instance.root) === instance)
2141 | return "Root";
2142 | for (const key in (_b25 = (_a25 = instance.parent) == null ? void 0 : _a25.type) == null ? void 0 : _b25.components) {
2143 | if (instance.parent.type.components[key] === (instance == null ? void 0 : instance.type))
2144 | return saveComponentGussedName(instance, key);
2145 | }
2146 | for (const key in (_c = instance.appContext) == null ? void 0 : _c.components) {
2147 | if (instance.appContext.components[key] === (instance == null ? void 0 : instance.type))
2148 | return saveComponentGussedName(instance, key);
2149 | }
2150 | const fileName = getComponentFileName((instance == null ? void 0 : instance.type) || {});
2151 | if (fileName)
2152 | return fileName;
2153 | return "Anonymous Component";
2154 | }
2155 | function getUniqueComponentId(instance) {
2156 | var _a25, _b25, _c;
2157 | const appId = (_c = (_b25 = (_a25 = instance == null ? void 0 : instance.appContext) == null ? void 0 : _a25.app) == null ? void 0 : _b25.__VUE_DEVTOOLS_NEXT_APP_RECORD_ID__) != null ? _c : 0;
2158 | const instanceId = instance === (instance == null ? void 0 : instance.root) ? "root" : instance.uid;
2159 | return `${appId}:${instanceId}`;
2160 | }
2161 | function getComponentInstance(appRecord, instanceId) {
2162 | instanceId = instanceId || `${appRecord.id}:root`;
2163 | const instance = appRecord.instanceMap.get(instanceId);
2164 | return instance || appRecord.instanceMap.get(":root");
2165 | }
2166 | function createRect() {
2167 | const rect = {
2168 | top: 0,
2169 | bottom: 0,
2170 | left: 0,
2171 | right: 0,
2172 | get width() {
2173 | return rect.right - rect.left;
2174 | },
2175 | get height() {
2176 | return rect.bottom - rect.top;
2177 | }
2178 | };
2179 | return rect;
2180 | }
2181 | var range;
2182 | function getTextRect(node) {
2183 | if (!range)
2184 | range = document.createRange();
2185 | range.selectNode(node);
2186 | return range.getBoundingClientRect();
2187 | }
2188 | function getFragmentRect(vnode) {
2189 | const rect = createRect();
2190 | if (!vnode.children)
2191 | return rect;
2192 | for (let i = 0, l = vnode.children.length; i < l; i++) {
2193 | const childVnode = vnode.children[i];
2194 | let childRect;
2195 | if (childVnode.component) {
2196 | childRect = getComponentBoundingRect(childVnode.component);
2197 | } else if (childVnode.el) {
2198 | const el = childVnode.el;
2199 | if (el.nodeType === 1 || el.getBoundingClientRect)
2200 | childRect = el.getBoundingClientRect();
2201 | else if (el.nodeType === 3 && el.data.trim())
2202 | childRect = getTextRect(el);
2203 | }
2204 | if (childRect)
2205 | mergeRects(rect, childRect);
2206 | }
2207 | return rect;
2208 | }
2209 | function mergeRects(a, b) {
2210 | if (!a.top || b.top < a.top)
2211 | a.top = b.top;
2212 | if (!a.bottom || b.bottom > a.bottom)
2213 | a.bottom = b.bottom;
2214 | if (!a.left || b.left < a.left)
2215 | a.left = b.left;
2216 | if (!a.right || b.right > a.right)
2217 | a.right = b.right;
2218 | return a;
2219 | }
2220 | var DEFAULT_RECT = {
2221 | top: 0,
2222 | left: 0,
2223 | right: 0,
2224 | bottom: 0,
2225 | width: 0,
2226 | height: 0
2227 | };
2228 | function getComponentBoundingRect(instance) {
2229 | const el = instance.subTree.el;
2230 | if (typeof window === "undefined") {
2231 | return DEFAULT_RECT;
2232 | }
2233 | if (isFragment(instance))
2234 | return getFragmentRect(instance.subTree);
2235 | else if ((el == null ? void 0 : el.nodeType) === 1)
2236 | return el == null ? void 0 : el.getBoundingClientRect();
2237 | else if (instance.subTree.component)
2238 | return getComponentBoundingRect(instance.subTree.component);
2239 | else
2240 | return DEFAULT_RECT;
2241 | }
2242 | init_esm_shims2();
2243 | function getRootElementsFromComponentInstance(instance) {
2244 | if (isFragment(instance))
2245 | return getFragmentRootElements(instance.subTree);
2246 | if (!instance.subTree)
2247 | return [];
2248 | return [instance.subTree.el];
2249 | }
2250 | function getFragmentRootElements(vnode) {
2251 | if (!vnode.children)
2252 | return [];
2253 | const list = [];
2254 | vnode.children.forEach((childVnode) => {
2255 | if (childVnode.component)
2256 | list.push(...getRootElementsFromComponentInstance(childVnode.component));
2257 | else if (childVnode == null ? void 0 : childVnode.el)
2258 | list.push(childVnode.el);
2259 | });
2260 | return list;
2261 | }
2262 | var CONTAINER_ELEMENT_ID = "__vue-devtools-component-inspector__";
2263 | var CARD_ELEMENT_ID = "__vue-devtools-component-inspector__card__";
2264 | var COMPONENT_NAME_ELEMENT_ID = "__vue-devtools-component-inspector__name__";
2265 | var INDICATOR_ELEMENT_ID = "__vue-devtools-component-inspector__indicator__";
2266 | var containerStyles = {
2267 | display: "block",
2268 | zIndex: 2147483640,
2269 | position: "fixed",
2270 | backgroundColor: "#42b88325",
2271 | border: "1px solid #42b88350",
2272 | borderRadius: "5px",
2273 | transition: "all 0.1s ease-in",
2274 | pointerEvents: "none"
2275 | };
2276 | var cardStyles = {
2277 | fontFamily: "Arial, Helvetica, sans-serif",
2278 | padding: "5px 8px",
2279 | borderRadius: "4px",
2280 | textAlign: "left",
2281 | position: "absolute",
2282 | left: 0,
2283 | color: "#e9e9e9",
2284 | fontSize: "14px",
2285 | fontWeight: 600,
2286 | lineHeight: "24px",
2287 | backgroundColor: "#42b883",
2288 | boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)"
2289 | };
2290 | var indicatorStyles = {
2291 | display: "inline-block",
2292 | fontWeight: 400,
2293 | fontStyle: "normal",
2294 | fontSize: "12px",
2295 | opacity: 0.7
2296 | };
2297 | function getContainerElement() {
2298 | return document.getElementById(CONTAINER_ELEMENT_ID);
2299 | }
2300 | function getCardElement() {
2301 | return document.getElementById(CARD_ELEMENT_ID);
2302 | }
2303 | function getIndicatorElement() {
2304 | return document.getElementById(INDICATOR_ELEMENT_ID);
2305 | }
2306 | function getNameElement() {
2307 | return document.getElementById(COMPONENT_NAME_ELEMENT_ID);
2308 | }
2309 | function getStyles(bounds) {
2310 | return {
2311 | left: `${Math.round(bounds.left * 100) / 100}px`,
2312 | top: `${Math.round(bounds.top * 100) / 100}px`,
2313 | width: `${Math.round(bounds.width * 100) / 100}px`,
2314 | height: `${Math.round(bounds.height * 100) / 100}px`
2315 | };
2316 | }
2317 | function create(options) {
2318 | var _a25;
2319 | const containerEl = document.createElement("div");
2320 | containerEl.id = (_a25 = options.elementId) != null ? _a25 : CONTAINER_ELEMENT_ID;
2321 | Object.assign(containerEl.style, {
2322 | ...containerStyles,
2323 | ...getStyles(options.bounds),
2324 | ...options.style
2325 | });
2326 | const cardEl = document.createElement("span");
2327 | cardEl.id = CARD_ELEMENT_ID;
2328 | Object.assign(cardEl.style, {
2329 | ...cardStyles,
2330 | top: options.bounds.top < 35 ? 0 : "-35px"
2331 | });
2332 | const nameEl = document.createElement("span");
2333 | nameEl.id = COMPONENT_NAME_ELEMENT_ID;
2334 | nameEl.innerHTML = `<${options.name}> `;
2335 | const indicatorEl = document.createElement("i");
2336 | indicatorEl.id = INDICATOR_ELEMENT_ID;
2337 | indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
2338 | Object.assign(indicatorEl.style, indicatorStyles);
2339 | cardEl.appendChild(nameEl);
2340 | cardEl.appendChild(indicatorEl);
2341 | containerEl.appendChild(cardEl);
2342 | document.body.appendChild(containerEl);
2343 | return containerEl;
2344 | }
2345 | function update(options) {
2346 | const containerEl = getContainerElement();
2347 | const cardEl = getCardElement();
2348 | const nameEl = getNameElement();
2349 | const indicatorEl = getIndicatorElement();
2350 | if (containerEl) {
2351 | Object.assign(containerEl.style, {
2352 | ...containerStyles,
2353 | ...getStyles(options.bounds)
2354 | });
2355 | Object.assign(cardEl.style, {
2356 | top: options.bounds.top < 35 ? 0 : "-35px"
2357 | });
2358 | nameEl.innerHTML = `<${options.name}> `;
2359 | indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
2360 | }
2361 | }
2362 | function highlight(instance) {
2363 | const bounds = getComponentBoundingRect(instance);
2364 | if (!bounds.width && !bounds.height)
2365 | return;
2366 | const name = getInstanceName(instance);
2367 | const container = getContainerElement();
2368 | container ? update({ bounds, name }) : create({ bounds, name });
2369 | }
2370 | function unhighlight() {
2371 | const el = getContainerElement();
2372 | if (el)
2373 | el.style.display = "none";
2374 | }
2375 | var inspectInstance = null;
2376 | function inspectFn(e) {
2377 | const target22 = e.target;
2378 | if (target22) {
2379 | const instance = target22.__vueParentComponent;
2380 | if (instance) {
2381 | inspectInstance = instance;
2382 | const el = instance.vnode.el;
2383 | if (el) {
2384 | const bounds = getComponentBoundingRect(instance);
2385 | const name = getInstanceName(instance);
2386 | const container = getContainerElement();
2387 | container ? update({ bounds, name }) : create({ bounds, name });
2388 | }
2389 | }
2390 | }
2391 | }
2392 | function selectComponentFn(e, cb) {
2393 | e.preventDefault();
2394 | e.stopPropagation();
2395 | if (inspectInstance) {
2396 | const uniqueComponentId = getUniqueComponentId(inspectInstance);
2397 | cb(uniqueComponentId);
2398 | }
2399 | }
2400 | var inspectComponentHighLighterSelectFn = null;
2401 | function cancelInspectComponentHighLighter() {
2402 | unhighlight();
2403 | window.removeEventListener("mouseover", inspectFn);
2404 | window.removeEventListener("click", inspectComponentHighLighterSelectFn, true);
2405 | inspectComponentHighLighterSelectFn = null;
2406 | }
2407 | function inspectComponentHighLighter() {
2408 | window.addEventListener("mouseover", inspectFn);
2409 | return new Promise((resolve) => {
2410 | function onSelect(e) {
2411 | e.preventDefault();
2412 | e.stopPropagation();
2413 | selectComponentFn(e, (id) => {
2414 | window.removeEventListener("click", onSelect, true);
2415 | inspectComponentHighLighterSelectFn = null;
2416 | window.removeEventListener("mouseover", inspectFn);
2417 | const el = getContainerElement();
2418 | if (el)
2419 | el.style.display = "none";
2420 | resolve(JSON.stringify({ id }));
2421 | });
2422 | }
2423 | inspectComponentHighLighterSelectFn = onSelect;
2424 | window.addEventListener("click", onSelect, true);
2425 | });
2426 | }
2427 | function scrollToComponent(options) {
2428 | const instance = getComponentInstance(activeAppRecord.value, options.id);
2429 | if (instance) {
2430 | const [el] = getRootElementsFromComponentInstance(instance);
2431 | if (typeof el.scrollIntoView === "function") {
2432 | el.scrollIntoView({
2433 | behavior: "smooth"
2434 | });
2435 | } else {
2436 | const bounds = getComponentBoundingRect(instance);
2437 | const scrollTarget = document.createElement("div");
2438 | const styles = {
2439 | ...getStyles(bounds),
2440 | position: "absolute"
2441 | };
2442 | Object.assign(scrollTarget.style, styles);
2443 | document.body.appendChild(scrollTarget);
2444 | scrollTarget.scrollIntoView({
2445 | behavior: "smooth"
2446 | });
2447 | setTimeout(() => {
2448 | document.body.removeChild(scrollTarget);
2449 | }, 2e3);
2450 | }
2451 | setTimeout(() => {
2452 | const bounds = getComponentBoundingRect(instance);
2453 | if (bounds.width || bounds.height) {
2454 | const name = getInstanceName(instance);
2455 | const el2 = getContainerElement();
2456 | el2 ? update({ ...options, name, bounds }) : create({ ...options, name, bounds });
2457 | setTimeout(() => {
2458 | if (el2)
2459 | el2.style.display = "none";
2460 | }, 1500);
2461 | }
2462 | }, 1200);
2463 | }
2464 | }
2465 | init_esm_shims2();
2466 | var _a2;
2467 | var _b;
2468 | (_b = (_a2 = target).__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__) != null ? _b : _a2.__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__ = true;
2469 | function waitForInspectorInit(cb) {
2470 | let total = 0;
2471 | const timer = setInterval(() => {
2472 | if (target.__VUE_INSPECTOR__) {
2473 | clearInterval(timer);
2474 | total += 30;
2475 | cb();
2476 | }
2477 | if (total >= /* 5s */
2478 | 5e3)
2479 | clearInterval(timer);
2480 | }, 30);
2481 | }
2482 | function setupInspector() {
2483 | const inspector = target.__VUE_INSPECTOR__;
2484 | const _openInEditor = inspector.openInEditor;
2485 | inspector.openInEditor = async (...params) => {
2486 | inspector.disable();
2487 | _openInEditor(...params);
2488 | };
2489 | }
2490 | function getComponentInspector() {
2491 | return new Promise((resolve) => {
2492 | function setup() {
2493 | setupInspector();
2494 | resolve(target.__VUE_INSPECTOR__);
2495 | }
2496 | if (!target.__VUE_INSPECTOR__) {
2497 | waitForInspectorInit(() => {
2498 | setup();
2499 | });
2500 | } else {
2501 | setup();
2502 | }
2503 | });
2504 | }
2505 | init_esm_shims2();
2506 | init_esm_shims2();
2507 | function isReadonly(value) {
2508 | return !!(value && value[
2509 | "__v_isReadonly"
2510 | /* IS_READONLY */
2511 | ]);
2512 | }
2513 | function isReactive(value) {
2514 | if (isReadonly(value)) {
2515 | return isReactive(value[
2516 | "__v_raw"
2517 | /* RAW */
2518 | ]);
2519 | }
2520 | return !!(value && value[
2521 | "__v_isReactive"
2522 | /* IS_REACTIVE */
2523 | ]);
2524 | }
2525 | function isRef(r) {
2526 | return !!(r && r.__v_isRef === true);
2527 | }
2528 | function toRaw(observed) {
2529 | const raw = observed && observed[
2530 | "__v_raw"
2531 | /* RAW */
2532 | ];
2533 | return raw ? toRaw(raw) : observed;
2534 | }
2535 | var Fragment = Symbol.for("v-fgt");
2536 | var StateEditor = class {
2537 | constructor() {
2538 | this.refEditor = new RefStateEditor();
2539 | }
2540 | set(object, path, value, cb) {
2541 | const sections = Array.isArray(path) ? path : path.split(".");
2542 | const markRef = false;
2543 | while (sections.length > 1) {
2544 | const section = sections.shift();
2545 | if (object instanceof Map)
2546 | object = object.get(section);
2547 | else if (object instanceof Set)
2548 | object = Array.from(object.values())[section];
2549 | else object = object[section];
2550 | if (this.refEditor.isRef(object))
2551 | object = this.refEditor.get(object);
2552 | }
2553 | const field = sections[0];
2554 | const item = this.refEditor.get(object)[field];
2555 | if (cb) {
2556 | cb(object, field, value);
2557 | } else {
2558 | if (this.refEditor.isRef(item))
2559 | this.refEditor.set(item, value);
2560 | else if (markRef)
2561 | object[field] = value;
2562 | else
2563 | object[field] = value;
2564 | }
2565 | }
2566 | get(object, path) {
2567 | const sections = Array.isArray(path) ? path : path.split(".");
2568 | for (let i = 0; i < sections.length; i++) {
2569 | if (object instanceof Map)
2570 | object = object.get(sections[i]);
2571 | else
2572 | object = object[sections[i]];
2573 | if (this.refEditor.isRef(object))
2574 | object = this.refEditor.get(object);
2575 | if (!object)
2576 | return void 0;
2577 | }
2578 | return object;
2579 | }
2580 | has(object, path, parent = false) {
2581 | if (typeof object === "undefined")
2582 | return false;
2583 | const sections = Array.isArray(path) ? path.slice() : path.split(".");
2584 | const size = !parent ? 1 : 2;
2585 | while (object && sections.length > size) {
2586 | const section = sections.shift();
2587 | object = object[section];
2588 | if (this.refEditor.isRef(object))
2589 | object = this.refEditor.get(object);
2590 | }
2591 | return object != null && Object.prototype.hasOwnProperty.call(object, sections[0]);
2592 | }
2593 | createDefaultSetCallback(state) {
2594 | return (object, field, value) => {
2595 | if (state.remove || state.newKey) {
2596 | if (Array.isArray(object))
2597 | object.splice(field, 1);
2598 | else if (toRaw(object) instanceof Map)
2599 | object.delete(field);
2600 | else if (toRaw(object) instanceof Set)
2601 | object.delete(Array.from(object.values())[field]);
2602 | else Reflect.deleteProperty(object, field);
2603 | }
2604 | if (!state.remove) {
2605 | const target22 = object[state.newKey || field];
2606 | if (this.refEditor.isRef(target22))
2607 | this.refEditor.set(target22, value);
2608 | else if (toRaw(object) instanceof Map)
2609 | object.set(state.newKey || field, value);
2610 | else if (toRaw(object) instanceof Set)
2611 | object.add(value);
2612 | else
2613 | object[state.newKey || field] = value;
2614 | }
2615 | };
2616 | }
2617 | };
2618 | var RefStateEditor = class {
2619 | set(ref, value) {
2620 | if (isRef(ref)) {
2621 | ref.value = value;
2622 | } else {
2623 | if (ref instanceof Set && Array.isArray(value)) {
2624 | ref.clear();
2625 | value.forEach((v) => ref.add(v));
2626 | return;
2627 | }
2628 | const currentKeys = Object.keys(value);
2629 | if (ref instanceof Map) {
2630 | const previousKeysSet2 = new Set(ref.keys());
2631 | currentKeys.forEach((key) => {
2632 | ref.set(key, Reflect.get(value, key));
2633 | previousKeysSet2.delete(key);
2634 | });
2635 | previousKeysSet2.forEach((key) => ref.delete(key));
2636 | return;
2637 | }
2638 | const previousKeysSet = new Set(Object.keys(ref));
2639 | currentKeys.forEach((key) => {
2640 | Reflect.set(ref, key, Reflect.get(value, key));
2641 | previousKeysSet.delete(key);
2642 | });
2643 | previousKeysSet.forEach((key) => Reflect.deleteProperty(ref, key));
2644 | }
2645 | }
2646 | get(ref) {
2647 | return isRef(ref) ? ref.value : ref;
2648 | }
2649 | isRef(ref) {
2650 | return isRef(ref) || isReactive(ref);
2651 | }
2652 | };
2653 | var stateEditor = new StateEditor();
2654 | init_esm_shims2();
2655 | init_esm_shims2();
2656 | init_esm_shims2();
2657 | var TIMELINE_LAYERS_STATE_STORAGE_ID = "__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS_STATE__";
2658 | function getTimelineLayersStateFromStorage() {
2659 | if (!isBrowser || typeof localStorage === "undefined" || localStorage === null) {
2660 | return {
2661 | recordingState: false,
2662 | mouseEventEnabled: false,
2663 | keyboardEventEnabled: false,
2664 | componentEventEnabled: false,
2665 | performanceEventEnabled: false,
2666 | selected: ""
2667 | };
2668 | }
2669 | const state = localStorage.getItem(TIMELINE_LAYERS_STATE_STORAGE_ID);
2670 | return state ? JSON.parse(state) : {
2671 | recordingState: false,
2672 | mouseEventEnabled: false,
2673 | keyboardEventEnabled: false,
2674 | componentEventEnabled: false,
2675 | performanceEventEnabled: false,
2676 | selected: ""
2677 | };
2678 | }
2679 | init_esm_shims2();
2680 | init_esm_shims2();
2681 | init_esm_shims2();
2682 | var _a22;
2683 | var _b2;
2684 | (_b2 = (_a22 = target).__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS) != null ? _b2 : _a22.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS = [];
2685 | var devtoolsTimelineLayers = new Proxy(target.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS, {
2686 | get(target22, prop, receiver) {
2687 | return Reflect.get(target22, prop, receiver);
2688 | }
2689 | });
2690 | function addTimelineLayer(options, descriptor) {
2691 | devtoolsState.timelineLayersState[descriptor.id] = false;
2692 | devtoolsTimelineLayers.push({
2693 | ...options,
2694 | descriptorId: descriptor.id,
2695 | appRecord: getAppRecord(descriptor.app)
2696 | });
2697 | }
2698 | var _a3;
2699 | var _b3;
2700 | (_b3 = (_a3 = target).__VUE_DEVTOOLS_KIT_INSPECTOR__) != null ? _b3 : _a3.__VUE_DEVTOOLS_KIT_INSPECTOR__ = [];
2701 | var devtoolsInspector = new Proxy(target.__VUE_DEVTOOLS_KIT_INSPECTOR__, {
2702 | get(target22, prop, receiver) {
2703 | return Reflect.get(target22, prop, receiver);
2704 | }
2705 | });
2706 | var callInspectorUpdatedHook = debounce(() => {
2707 | devtoolsContext.hooks.callHook("sendInspectorToClient", getActiveInspectors());
2708 | });
2709 | function addInspector(inspector, descriptor) {
2710 | var _a25, _b25;
2711 | devtoolsInspector.push({
2712 | options: inspector,
2713 | descriptor,
2714 | treeFilterPlaceholder: (_a25 = inspector.treeFilterPlaceholder) != null ? _a25 : "Search tree...",
2715 | stateFilterPlaceholder: (_b25 = inspector.stateFilterPlaceholder) != null ? _b25 : "Search state...",
2716 | treeFilter: "",
2717 | selectedNodeId: "",
2718 | appRecord: getAppRecord(descriptor.app)
2719 | });
2720 | callInspectorUpdatedHook();
2721 | }
2722 | function getActiveInspectors() {
2723 | return devtoolsInspector.filter((inspector) => inspector.descriptor.app === activeAppRecord.value.app).filter((inspector) => inspector.descriptor.id !== "components").map((inspector) => {
2724 | var _a25;
2725 | const descriptor = inspector.descriptor;
2726 | const options = inspector.options;
2727 | return {
2728 | id: options.id,
2729 | label: options.label,
2730 | logo: descriptor.logo,
2731 | icon: `custom-ic-baseline-${(_a25 = options == null ? void 0 : options.icon) == null ? void 0 : _a25.replace(/_/g, "-")}`,
2732 | packageName: descriptor.packageName,
2733 | homepage: descriptor.homepage,
2734 | pluginId: descriptor.id
2735 | };
2736 | });
2737 | }
2738 | function getInspector(id, app) {
2739 | return devtoolsInspector.find((inspector) => inspector.options.id === id && (app ? inspector.descriptor.app === app : true));
2740 | }
2741 | var DevToolsV6PluginAPIHookKeys = ((DevToolsV6PluginAPIHookKeys2) => {
2742 | DevToolsV6PluginAPIHookKeys2["VISIT_COMPONENT_TREE"] = "visitComponentTree";
2743 | DevToolsV6PluginAPIHookKeys2["INSPECT_COMPONENT"] = "inspectComponent";
2744 | DevToolsV6PluginAPIHookKeys2["EDIT_COMPONENT_STATE"] = "editComponentState";
2745 | DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_TREE"] = "getInspectorTree";
2746 | DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_STATE"] = "getInspectorState";
2747 | DevToolsV6PluginAPIHookKeys2["EDIT_INSPECTOR_STATE"] = "editInspectorState";
2748 | DevToolsV6PluginAPIHookKeys2["INSPECT_TIMELINE_EVENT"] = "inspectTimelineEvent";
2749 | DevToolsV6PluginAPIHookKeys2["TIMELINE_CLEARED"] = "timelineCleared";
2750 | DevToolsV6PluginAPIHookKeys2["SET_PLUGIN_SETTINGS"] = "setPluginSettings";
2751 | return DevToolsV6PluginAPIHookKeys2;
2752 | })(DevToolsV6PluginAPIHookKeys || {});
2753 | var DevToolsContextHookKeys = ((DevToolsContextHookKeys2) => {
2754 | DevToolsContextHookKeys2["ADD_INSPECTOR"] = "addInspector";
2755 | DevToolsContextHookKeys2["SEND_INSPECTOR_TREE"] = "sendInspectorTree";
2756 | DevToolsContextHookKeys2["SEND_INSPECTOR_STATE"] = "sendInspectorState";
2757 | DevToolsContextHookKeys2["CUSTOM_INSPECTOR_SELECT_NODE"] = "customInspectorSelectNode";
2758 | DevToolsContextHookKeys2["TIMELINE_LAYER_ADDED"] = "timelineLayerAdded";
2759 | DevToolsContextHookKeys2["TIMELINE_EVENT_ADDED"] = "timelineEventAdded";
2760 | DevToolsContextHookKeys2["GET_COMPONENT_INSTANCES"] = "getComponentInstances";
2761 | DevToolsContextHookKeys2["GET_COMPONENT_BOUNDS"] = "getComponentBounds";
2762 | DevToolsContextHookKeys2["GET_COMPONENT_NAME"] = "getComponentName";
2763 | DevToolsContextHookKeys2["COMPONENT_HIGHLIGHT"] = "componentHighlight";
2764 | DevToolsContextHookKeys2["COMPONENT_UNHIGHLIGHT"] = "componentUnhighlight";
2765 | return DevToolsContextHookKeys2;
2766 | })(DevToolsContextHookKeys || {});
2767 | var DevToolsMessagingHookKeys = ((DevToolsMessagingHookKeys2) => {
2768 | DevToolsMessagingHookKeys2["SEND_INSPECTOR_TREE_TO_CLIENT"] = "sendInspectorTreeToClient";
2769 | DevToolsMessagingHookKeys2["SEND_INSPECTOR_STATE_TO_CLIENT"] = "sendInspectorStateToClient";
2770 | DevToolsMessagingHookKeys2["SEND_TIMELINE_EVENT_TO_CLIENT"] = "sendTimelineEventToClient";
2771 | DevToolsMessagingHookKeys2["SEND_INSPECTOR_TO_CLIENT"] = "sendInspectorToClient";
2772 | DevToolsMessagingHookKeys2["SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT"] = "sendActiveAppUpdatedToClient";
2773 | DevToolsMessagingHookKeys2["DEVTOOLS_STATE_UPDATED"] = "devtoolsStateUpdated";
2774 | DevToolsMessagingHookKeys2["DEVTOOLS_CONNECTED_UPDATED"] = "devtoolsConnectedUpdated";
2775 | DevToolsMessagingHookKeys2["ROUTER_INFO_UPDATED"] = "routerInfoUpdated";
2776 | return DevToolsMessagingHookKeys2;
2777 | })(DevToolsMessagingHookKeys || {});
2778 | function createDevToolsCtxHooks() {
2779 | const hooks2 = createHooks();
2780 | hooks2.hook("addInspector", ({ inspector, plugin }) => {
2781 | addInspector(inspector, plugin.descriptor);
2782 | });
2783 | const debounceSendInspectorTree = debounce(async ({ inspectorId, plugin }) => {
2784 | var _a25;
2785 | if (!inspectorId || !((_a25 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a25.app) || devtoolsState.highPerfModeEnabled)
2786 | return;
2787 | const inspector = getInspector(inspectorId, plugin.descriptor.app);
2788 | const _payload = {
2789 | app: plugin.descriptor.app,
2790 | inspectorId,
2791 | filter: (inspector == null ? void 0 : inspector.treeFilter) || "",
2792 | rootNodes: []
2793 | };
2794 | await new Promise((resolve) => {
2795 | hooks2.callHookWith(
2796 | async (callbacks) => {
2797 | await Promise.all(callbacks.map((cb) => cb(_payload)));
2798 | resolve();
2799 | },
2800 | "getInspectorTree"
2801 | /* GET_INSPECTOR_TREE */
2802 | );
2803 | });
2804 | hooks2.callHookWith(
2805 | async (callbacks) => {
2806 | await Promise.all(callbacks.map((cb) => cb({
2807 | inspectorId,
2808 | rootNodes: _payload.rootNodes
2809 | })));
2810 | },
2811 | "sendInspectorTreeToClient"
2812 | /* SEND_INSPECTOR_TREE_TO_CLIENT */
2813 | );
2814 | }, 120);
2815 | hooks2.hook("sendInspectorTree", debounceSendInspectorTree);
2816 | const debounceSendInspectorState = debounce(async ({ inspectorId, plugin }) => {
2817 | var _a25;
2818 | if (!inspectorId || !((_a25 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a25.app) || devtoolsState.highPerfModeEnabled)
2819 | return;
2820 | const inspector = getInspector(inspectorId, plugin.descriptor.app);
2821 | const _payload = {
2822 | app: plugin.descriptor.app,
2823 | inspectorId,
2824 | nodeId: (inspector == null ? void 0 : inspector.selectedNodeId) || "",
2825 | state: null
2826 | };
2827 | const ctx = {
2828 | currentTab: `custom-inspector:${inspectorId}`
2829 | };
2830 | if (_payload.nodeId) {
2831 | await new Promise((resolve) => {
2832 | hooks2.callHookWith(
2833 | async (callbacks) => {
2834 | await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
2835 | resolve();
2836 | },
2837 | "getInspectorState"
2838 | /* GET_INSPECTOR_STATE */
2839 | );
2840 | });
2841 | }
2842 | hooks2.callHookWith(
2843 | async (callbacks) => {
2844 | await Promise.all(callbacks.map((cb) => cb({
2845 | inspectorId,
2846 | nodeId: _payload.nodeId,
2847 | state: _payload.state
2848 | })));
2849 | },
2850 | "sendInspectorStateToClient"
2851 | /* SEND_INSPECTOR_STATE_TO_CLIENT */
2852 | );
2853 | }, 120);
2854 | hooks2.hook("sendInspectorState", debounceSendInspectorState);
2855 | hooks2.hook("customInspectorSelectNode", ({ inspectorId, nodeId, plugin }) => {
2856 | const inspector = getInspector(inspectorId, plugin.descriptor.app);
2857 | if (!inspector)
2858 | return;
2859 | inspector.selectedNodeId = nodeId;
2860 | });
2861 | hooks2.hook("timelineLayerAdded", ({ options, plugin }) => {
2862 | addTimelineLayer(options, plugin.descriptor);
2863 | });
2864 | hooks2.hook("timelineEventAdded", ({ options, plugin }) => {
2865 | var _a25;
2866 | const internalLayerIds = ["performance", "component-event", "keyboard", "mouse"];
2867 | if (devtoolsState.highPerfModeEnabled || !((_a25 = devtoolsState.timelineLayersState) == null ? void 0 : _a25[plugin.descriptor.id]) && !internalLayerIds.includes(options.layerId))
2868 | return;
2869 | hooks2.callHookWith(
2870 | async (callbacks) => {
2871 | await Promise.all(callbacks.map((cb) => cb(options)));
2872 | },
2873 | "sendTimelineEventToClient"
2874 | /* SEND_TIMELINE_EVENT_TO_CLIENT */
2875 | );
2876 | });
2877 | hooks2.hook("getComponentInstances", async ({ app }) => {
2878 | const appRecord = app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
2879 | if (!appRecord)
2880 | return null;
2881 | const appId = appRecord.id.toString();
2882 | const instances = [...appRecord.instanceMap].filter(([key]) => key.split(":")[0] === appId).map(([, instance]) => instance);
2883 | return instances;
2884 | });
2885 | hooks2.hook("getComponentBounds", async ({ instance }) => {
2886 | const bounds = getComponentBoundingRect(instance);
2887 | return bounds;
2888 | });
2889 | hooks2.hook("getComponentName", ({ instance }) => {
2890 | const name = getInstanceName(instance);
2891 | return name;
2892 | });
2893 | hooks2.hook("componentHighlight", ({ uid }) => {
2894 | const instance = activeAppRecord.value.instanceMap.get(uid);
2895 | if (instance) {
2896 | highlight(instance);
2897 | }
2898 | });
2899 | hooks2.hook("componentUnhighlight", () => {
2900 | unhighlight();
2901 | });
2902 | return hooks2;
2903 | }
2904 | var _a4;
2905 | var _b4;
2906 | (_b4 = (_a4 = target).__VUE_DEVTOOLS_KIT_APP_RECORDS__) != null ? _b4 : _a4.__VUE_DEVTOOLS_KIT_APP_RECORDS__ = [];
2907 | var _a5;
2908 | var _b5;
2909 | (_b5 = (_a5 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__) != null ? _b5 : _a5.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = {};
2910 | var _a6;
2911 | var _b6;
2912 | (_b6 = (_a6 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__) != null ? _b6 : _a6.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = "";
2913 | var _a7;
2914 | var _b7;
2915 | (_b7 = (_a7 = target).__VUE_DEVTOOLS_KIT_CUSTOM_TABS__) != null ? _b7 : _a7.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__ = [];
2916 | var _a8;
2917 | var _b8;
2918 | (_b8 = (_a8 = target).__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__) != null ? _b8 : _a8.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__ = [];
2919 | var STATE_KEY = "__VUE_DEVTOOLS_KIT_GLOBAL_STATE__";
2920 | function initStateFactory() {
2921 | return {
2922 | connected: false,
2923 | clientConnected: false,
2924 | vitePluginDetected: true,
2925 | appRecords: [],
2926 | activeAppRecordId: "",
2927 | tabs: [],
2928 | commands: [],
2929 | highPerfModeEnabled: true,
2930 | devtoolsClientDetected: {},
2931 | perfUniqueGroupId: 0,
2932 | timelineLayersState: getTimelineLayersStateFromStorage()
2933 | };
2934 | }
2935 | var _a9;
2936 | var _b9;
2937 | (_b9 = (_a9 = target)[STATE_KEY]) != null ? _b9 : _a9[STATE_KEY] = initStateFactory();
2938 | var callStateUpdatedHook = debounce((state) => {
2939 | devtoolsContext.hooks.callHook("devtoolsStateUpdated", { state });
2940 | });
2941 | var callConnectedUpdatedHook = debounce((state, oldState) => {
2942 | devtoolsContext.hooks.callHook("devtoolsConnectedUpdated", { state, oldState });
2943 | });
2944 | var devtoolsAppRecords = new Proxy(target.__VUE_DEVTOOLS_KIT_APP_RECORDS__, {
2945 | get(_target, prop, receiver) {
2946 | if (prop === "value")
2947 | return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__;
2948 | return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__[prop];
2949 | }
2950 | });
2951 | var activeAppRecord = new Proxy(target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__, {
2952 | get(_target, prop, receiver) {
2953 | if (prop === "value")
2954 | return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__;
2955 | else if (prop === "id")
2956 | return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__;
2957 | return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__[prop];
2958 | }
2959 | });
2960 | function updateAllStates() {
2961 | callStateUpdatedHook({
2962 | ...target[STATE_KEY],
2963 | appRecords: devtoolsAppRecords.value,
2964 | activeAppRecordId: activeAppRecord.id,
2965 | tabs: target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__,
2966 | commands: target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__
2967 | });
2968 | }
2969 | function setActiveAppRecord(app) {
2970 | target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = app;
2971 | updateAllStates();
2972 | }
2973 | function setActiveAppRecordId(id) {
2974 | target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = id;
2975 | updateAllStates();
2976 | }
2977 | var devtoolsState = new Proxy(target[STATE_KEY], {
2978 | get(target22, property) {
2979 | if (property === "appRecords") {
2980 | return devtoolsAppRecords;
2981 | } else if (property === "activeAppRecordId") {
2982 | return activeAppRecord.id;
2983 | } else if (property === "tabs") {
2984 | return target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
2985 | } else if (property === "commands") {
2986 | return target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
2987 | }
2988 | return target[STATE_KEY][property];
2989 | },
2990 | deleteProperty(target22, property) {
2991 | delete target22[property];
2992 | return true;
2993 | },
2994 | set(target22, property, value) {
2995 | const oldState = { ...target[STATE_KEY] };
2996 | target22[property] = value;
2997 | target[STATE_KEY][property] = value;
2998 | return true;
2999 | }
3000 | });
3001 | function onDevToolsConnected(fn) {
3002 | return new Promise((resolve) => {
3003 | if (devtoolsState.connected) {
3004 | fn();
3005 | resolve();
3006 | }
3007 | devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
3008 | if (state.connected) {
3009 | fn();
3010 | resolve();
3011 | }
3012 | });
3013 | });
3014 | }
3015 | var resolveIcon = (icon) => {
3016 | if (!icon)
3017 | return;
3018 | if (icon.startsWith("baseline-")) {
3019 | return `custom-ic-${icon}`;
3020 | }
3021 | if (icon.startsWith("i-") || isUrlString(icon))
3022 | return icon;
3023 | return `custom-ic-baseline-${icon}`;
3024 | };
3025 | function addCustomTab(tab) {
3026 | const tabs = target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
3027 | if (tabs.some((t) => t.name === tab.name))
3028 | return;
3029 | tabs.push({
3030 | ...tab,
3031 | icon: resolveIcon(tab.icon)
3032 | });
3033 | updateAllStates();
3034 | }
3035 | function addCustomCommand(action) {
3036 | const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
3037 | if (commands.some((t) => t.id === action.id))
3038 | return;
3039 | commands.push({
3040 | ...action,
3041 | icon: resolveIcon(action.icon),
3042 | children: action.children ? action.children.map((child) => ({
3043 | ...child,
3044 | icon: resolveIcon(child.icon)
3045 | })) : void 0
3046 | });
3047 | updateAllStates();
3048 | }
3049 | function removeCustomCommand(actionId) {
3050 | const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
3051 | const index = commands.findIndex((t) => t.id === actionId);
3052 | if (index === -1)
3053 | return;
3054 | commands.splice(index, 1);
3055 | updateAllStates();
3056 | }
3057 | function openInEditor(options = {}) {
3058 | var _a25, _b25, _c;
3059 | const { file, host, baseUrl = window.location.origin, line = 0, column = 0 } = options;
3060 | if (file) {
3061 | if (host === "chrome-extension") {
3062 | const fileName = file.replace(/\\/g, "\\\\");
3063 | const _baseUrl = (_b25 = (_a25 = window.VUE_DEVTOOLS_CONFIG) == null ? void 0 : _a25.openInEditorHost) != null ? _b25 : "/";
3064 | fetch(`${_baseUrl}__open-in-editor?file=${encodeURI(file)}`).then((response) => {
3065 | if (!response.ok) {
3066 | const msg = `Opening component ${fileName} failed`;
3067 | console.log(`%c${msg}`, "color:red");
3068 | }
3069 | });
3070 | } else if (devtoolsState.vitePluginDetected) {
3071 | const _baseUrl = (_c = target.__VUE_DEVTOOLS_OPEN_IN_EDITOR_BASE_URL__) != null ? _c : baseUrl;
3072 | target.__VUE_INSPECTOR__.openInEditor(_baseUrl, file, line, column);
3073 | }
3074 | }
3075 | }
3076 | init_esm_shims2();
3077 | init_esm_shims2();
3078 | init_esm_shims2();
3079 | init_esm_shims2();
3080 | init_esm_shims2();
3081 | var _a10;
3082 | var _b10;
3083 | (_b10 = (_a10 = target).__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__) != null ? _b10 : _a10.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__ = [];
3084 | var devtoolsPluginBuffer = new Proxy(target.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__, {
3085 | get(target22, prop, receiver) {
3086 | return Reflect.get(target22, prop, receiver);
3087 | }
3088 | });
3089 | function _getSettings(settings) {
3090 | const _settings = {};
3091 | Object.keys(settings).forEach((key) => {
3092 | _settings[key] = settings[key].defaultValue;
3093 | });
3094 | return _settings;
3095 | }
3096 | function getPluginLocalKey(pluginId) {
3097 | return `__VUE_DEVTOOLS_NEXT_PLUGIN_SETTINGS__${pluginId}__`;
3098 | }
3099 | function getPluginSettingsOptions(pluginId) {
3100 | var _a25, _b25, _c;
3101 | const item = (_b25 = (_a25 = devtoolsPluginBuffer.find((item2) => {
3102 | var _a26;
3103 | return item2[0].id === pluginId && !!((_a26 = item2[0]) == null ? void 0 : _a26.settings);
3104 | })) == null ? void 0 : _a25[0]) != null ? _b25 : null;
3105 | return (_c = item == null ? void 0 : item.settings) != null ? _c : null;
3106 | }
3107 | function getPluginSettings(pluginId, fallbackValue) {
3108 | var _a25, _b25, _c;
3109 | const localKey = getPluginLocalKey(pluginId);
3110 | if (localKey) {
3111 | const localSettings = localStorage.getItem(localKey);
3112 | if (localSettings) {
3113 | return JSON.parse(localSettings);
3114 | }
3115 | }
3116 | if (pluginId) {
3117 | const item = (_b25 = (_a25 = devtoolsPluginBuffer.find((item2) => item2[0].id === pluginId)) == null ? void 0 : _a25[0]) != null ? _b25 : null;
3118 | return _getSettings((_c = item == null ? void 0 : item.settings) != null ? _c : {});
3119 | }
3120 | return _getSettings(fallbackValue);
3121 | }
3122 | function initPluginSettings(pluginId, settings) {
3123 | const localKey = getPluginLocalKey(pluginId);
3124 | const localSettings = localStorage.getItem(localKey);
3125 | if (!localSettings) {
3126 | localStorage.setItem(localKey, JSON.stringify(_getSettings(settings)));
3127 | }
3128 | }
3129 | function setPluginSettings(pluginId, key, value) {
3130 | const localKey = getPluginLocalKey(pluginId);
3131 | const localSettings = localStorage.getItem(localKey);
3132 | const parsedLocalSettings = JSON.parse(localSettings || "{}");
3133 | const updated = {
3134 | ...parsedLocalSettings,
3135 | [key]: value
3136 | };
3137 | localStorage.setItem(localKey, JSON.stringify(updated));
3138 | devtoolsContext.hooks.callHookWith(
3139 | (callbacks) => {
3140 | callbacks.forEach((cb) => cb({
3141 | pluginId,
3142 | key,
3143 | oldValue: parsedLocalSettings[key],
3144 | newValue: value,
3145 | settings: updated
3146 | }));
3147 | },
3148 | "setPluginSettings"
3149 | /* SET_PLUGIN_SETTINGS */
3150 | );
3151 | }
3152 | init_esm_shims2();
3153 | init_esm_shims2();
3154 | init_esm_shims2();
3155 | init_esm_shims2();
3156 | init_esm_shims2();
3157 | init_esm_shims2();
3158 | init_esm_shims2();
3159 | init_esm_shims2();
3160 | init_esm_shims2();
3161 | init_esm_shims2();
3162 | init_esm_shims2();
3163 | var _a11;
3164 | var _b11;
3165 | var devtoolsHooks = (_b11 = (_a11 = target).__VUE_DEVTOOLS_HOOK) != null ? _b11 : _a11.__VUE_DEVTOOLS_HOOK = createHooks();
3166 | var on = {
3167 | vueAppInit(fn) {
3168 | devtoolsHooks.hook("app:init", fn);
3169 | },
3170 | vueAppUnmount(fn) {
3171 | devtoolsHooks.hook("app:unmount", fn);
3172 | },
3173 | vueAppConnected(fn) {
3174 | devtoolsHooks.hook("app:connected", fn);
3175 | },
3176 | componentAdded(fn) {
3177 | return devtoolsHooks.hook("component:added", fn);
3178 | },
3179 | componentEmit(fn) {
3180 | return devtoolsHooks.hook("component:emit", fn);
3181 | },
3182 | componentUpdated(fn) {
3183 | return devtoolsHooks.hook("component:updated", fn);
3184 | },
3185 | componentRemoved(fn) {
3186 | return devtoolsHooks.hook("component:removed", fn);
3187 | },
3188 | setupDevtoolsPlugin(fn) {
3189 | devtoolsHooks.hook("devtools-plugin:setup", fn);
3190 | },
3191 | perfStart(fn) {
3192 | return devtoolsHooks.hook("perf:start", fn);
3193 | },
3194 | perfEnd(fn) {
3195 | return devtoolsHooks.hook("perf:end", fn);
3196 | }
3197 | };
3198 | var hook = {
3199 | on,
3200 | setupDevToolsPlugin(pluginDescriptor, setupFn) {
3201 | return devtoolsHooks.callHook("devtools-plugin:setup", pluginDescriptor, setupFn);
3202 | }
3203 | };
3204 | var DevToolsV6PluginAPI = class {
3205 | constructor({ plugin, ctx }) {
3206 | this.hooks = ctx.hooks;
3207 | this.plugin = plugin;
3208 | }
3209 | get on() {
3210 | return {
3211 | // component inspector
3212 | visitComponentTree: (handler) => {
3213 | this.hooks.hook("visitComponentTree", handler);
3214 | },
3215 | inspectComponent: (handler) => {
3216 | this.hooks.hook("inspectComponent", handler);
3217 | },
3218 | editComponentState: (handler) => {
3219 | this.hooks.hook("editComponentState", handler);
3220 | },
3221 | // custom inspector
3222 | getInspectorTree: (handler) => {
3223 | this.hooks.hook("getInspectorTree", handler);
3224 | },
3225 | getInspectorState: (handler) => {
3226 | this.hooks.hook("getInspectorState", handler);
3227 | },
3228 | editInspectorState: (handler) => {
3229 | this.hooks.hook("editInspectorState", handler);
3230 | },
3231 | // timeline
3232 | inspectTimelineEvent: (handler) => {
3233 | this.hooks.hook("inspectTimelineEvent", handler);
3234 | },
3235 | timelineCleared: (handler) => {
3236 | this.hooks.hook("timelineCleared", handler);
3237 | },
3238 | // settings
3239 | setPluginSettings: (handler) => {
3240 | this.hooks.hook("setPluginSettings", handler);
3241 | }
3242 | };
3243 | }
3244 | // component inspector
3245 | notifyComponentUpdate(instance) {
3246 | var _a25;
3247 | if (devtoolsState.highPerfModeEnabled) {
3248 | return;
3249 | }
3250 | const inspector = getActiveInspectors().find((i) => i.packageName === this.plugin.descriptor.packageName);
3251 | if (inspector == null ? void 0 : inspector.id) {
3252 | if (instance) {
3253 | const args = [
3254 | instance.appContext.app,
3255 | instance.uid,
3256 | (_a25 = instance.parent) == null ? void 0 : _a25.uid,
3257 | instance
3258 | ];
3259 | devtoolsHooks.callHook("component:updated", ...args);
3260 | } else {
3261 | devtoolsHooks.callHook(
3262 | "component:updated"
3263 | /* COMPONENT_UPDATED */
3264 | );
3265 | }
3266 | this.hooks.callHook("sendInspectorState", { inspectorId: inspector.id, plugin: this.plugin });
3267 | }
3268 | }
3269 | // custom inspector
3270 | addInspector(options) {
3271 | this.hooks.callHook("addInspector", { inspector: options, plugin: this.plugin });
3272 | if (this.plugin.descriptor.settings) {
3273 | initPluginSettings(options.id, this.plugin.descriptor.settings);
3274 | }
3275 | }
3276 | sendInspectorTree(inspectorId) {
3277 | if (devtoolsState.highPerfModeEnabled) {
3278 | return;
3279 | }
3280 | this.hooks.callHook("sendInspectorTree", { inspectorId, plugin: this.plugin });
3281 | }
3282 | sendInspectorState(inspectorId) {
3283 | if (devtoolsState.highPerfModeEnabled) {
3284 | return;
3285 | }
3286 | this.hooks.callHook("sendInspectorState", { inspectorId, plugin: this.plugin });
3287 | }
3288 | selectInspectorNode(inspectorId, nodeId) {
3289 | this.hooks.callHook("customInspectorSelectNode", { inspectorId, nodeId, plugin: this.plugin });
3290 | }
3291 | visitComponentTree(payload) {
3292 | return this.hooks.callHook("visitComponentTree", payload);
3293 | }
3294 | // timeline
3295 | now() {
3296 | if (devtoolsState.highPerfModeEnabled) {
3297 | return 0;
3298 | }
3299 | return Date.now();
3300 | }
3301 | addTimelineLayer(options) {
3302 | this.hooks.callHook("timelineLayerAdded", { options, plugin: this.plugin });
3303 | }
3304 | addTimelineEvent(options) {
3305 | if (devtoolsState.highPerfModeEnabled) {
3306 | return;
3307 | }
3308 | this.hooks.callHook("timelineEventAdded", { options, plugin: this.plugin });
3309 | }
3310 | // settings
3311 | getSettings(pluginId) {
3312 | return getPluginSettings(pluginId != null ? pluginId : this.plugin.descriptor.id, this.plugin.descriptor.settings);
3313 | }
3314 | // utilities
3315 | getComponentInstances(app) {
3316 | return this.hooks.callHook("getComponentInstances", { app });
3317 | }
3318 | getComponentBounds(instance) {
3319 | return this.hooks.callHook("getComponentBounds", { instance });
3320 | }
3321 | getComponentName(instance) {
3322 | return this.hooks.callHook("getComponentName", { instance });
3323 | }
3324 | highlightElement(instance) {
3325 | const uid = instance.__VUE_DEVTOOLS_NEXT_UID__;
3326 | return this.hooks.callHook("componentHighlight", { uid });
3327 | }
3328 | unhighlightElement() {
3329 | return this.hooks.callHook(
3330 | "componentUnhighlight"
3331 | /* COMPONENT_UNHIGHLIGHT */
3332 | );
3333 | }
3334 | };
3335 | var DevToolsPluginAPI = DevToolsV6PluginAPI;
3336 | init_esm_shims2();
3337 | init_esm_shims2();
3338 | init_esm_shims2();
3339 | init_esm_shims2();
3340 | var UNDEFINED = "__vue_devtool_undefined__";
3341 | var INFINITY = "__vue_devtool_infinity__";
3342 | var NEGATIVE_INFINITY = "__vue_devtool_negative_infinity__";
3343 | var NAN = "__vue_devtool_nan__";
3344 | init_esm_shims2();
3345 | init_esm_shims2();
3346 | var tokenMap = {
3347 | [UNDEFINED]: "undefined",
3348 | [NAN]: "NaN",
3349 | [INFINITY]: "Infinity",
3350 | [NEGATIVE_INFINITY]: "-Infinity"
3351 | };
3352 | var reversedTokenMap = Object.entries(tokenMap).reduce((acc, [key, value]) => {
3353 | acc[value] = key;
3354 | return acc;
3355 | }, {});
3356 | init_esm_shims2();
3357 | init_esm_shims2();
3358 | init_esm_shims2();
3359 | init_esm_shims2();
3360 | init_esm_shims2();
3361 | var _a12;
3362 | var _b12;
3363 | (_b12 = (_a12 = target).__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__) != null ? _b12 : _a12.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__ = /* @__PURE__ */ new Set();
3364 | function setupDevToolsPlugin(pluginDescriptor, setupFn) {
3365 | return hook.setupDevToolsPlugin(pluginDescriptor, setupFn);
3366 | }
3367 | function callDevToolsPluginSetupFn(plugin, app) {
3368 | const [pluginDescriptor, setupFn] = plugin;
3369 | if (pluginDescriptor.app !== app)
3370 | return;
3371 | const api = new DevToolsPluginAPI({
3372 | plugin: {
3373 | setupFn,
3374 | descriptor: pluginDescriptor
3375 | },
3376 | ctx: devtoolsContext
3377 | });
3378 | if (pluginDescriptor.packageName === "vuex") {
3379 | api.on.editInspectorState((payload) => {
3380 | api.sendInspectorState(payload.inspectorId);
3381 | });
3382 | }
3383 | setupFn(api);
3384 | }
3385 | function registerDevToolsPlugin(app, options) {
3386 | if (target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.has(app)) {
3387 | return;
3388 | }
3389 | if (devtoolsState.highPerfModeEnabled && !(options == null ? void 0 : options.inspectingComponent)) {
3390 | return;
3391 | }
3392 | target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.add(app);
3393 | devtoolsPluginBuffer.forEach((plugin) => {
3394 | callDevToolsPluginSetupFn(plugin, app);
3395 | });
3396 | }
3397 | init_esm_shims2();
3398 | init_esm_shims2();
3399 | var ROUTER_KEY = "__VUE_DEVTOOLS_ROUTER__";
3400 | var ROUTER_INFO_KEY = "__VUE_DEVTOOLS_ROUTER_INFO__";
3401 | var _a13;
3402 | var _b13;
3403 | (_b13 = (_a13 = target)[ROUTER_INFO_KEY]) != null ? _b13 : _a13[ROUTER_INFO_KEY] = {
3404 | currentRoute: null,
3405 | routes: []
3406 | };
3407 | var _a14;
3408 | var _b14;
3409 | (_b14 = (_a14 = target)[ROUTER_KEY]) != null ? _b14 : _a14[ROUTER_KEY] = {};
3410 | var devtoolsRouterInfo = new Proxy(target[ROUTER_INFO_KEY], {
3411 | get(target22, property) {
3412 | return target[ROUTER_INFO_KEY][property];
3413 | }
3414 | });
3415 | var devtoolsRouter = new Proxy(target[ROUTER_KEY], {
3416 | get(target22, property) {
3417 | if (property === "value") {
3418 | return target[ROUTER_KEY];
3419 | }
3420 | }
3421 | });
3422 | function getRoutes(router) {
3423 | const routesMap = /* @__PURE__ */ new Map();
3424 | return ((router == null ? void 0 : router.getRoutes()) || []).filter((i) => !routesMap.has(i.path) && routesMap.set(i.path, 1));
3425 | }
3426 | function filterRoutes(routes) {
3427 | return routes.map((item) => {
3428 | let { path, name, children, meta } = item;
3429 | if (children == null ? void 0 : children.length)
3430 | children = filterRoutes(children);
3431 | return {
3432 | path,
3433 | name,
3434 | children,
3435 | meta
3436 | };
3437 | });
3438 | }
3439 | function filterCurrentRoute(route) {
3440 | if (route) {
3441 | const { fullPath, hash, href, path, name, matched, params, query } = route;
3442 | return {
3443 | fullPath,
3444 | hash,
3445 | href,
3446 | path,
3447 | name,
3448 | params,
3449 | query,
3450 | matched: filterRoutes(matched)
3451 | };
3452 | }
3453 | return route;
3454 | }
3455 | function normalizeRouterInfo(appRecord, activeAppRecord2) {
3456 | function init() {
3457 | var _a25;
3458 | const router = (_a25 = appRecord.app) == null ? void 0 : _a25.config.globalProperties.$router;
3459 | const currentRoute = filterCurrentRoute(router == null ? void 0 : router.currentRoute.value);
3460 | const routes = filterRoutes(getRoutes(router));
3461 | const c = console.warn;
3462 | console.warn = () => {
3463 | };
3464 | target[ROUTER_INFO_KEY] = {
3465 | currentRoute: currentRoute ? deepClone(currentRoute) : {},
3466 | routes: deepClone(routes)
3467 | };
3468 | target[ROUTER_KEY] = router;
3469 | console.warn = c;
3470 | }
3471 | init();
3472 | hook.on.componentUpdated(debounce(() => {
3473 | var _a25;
3474 | if (((_a25 = activeAppRecord2.value) == null ? void 0 : _a25.app) !== appRecord.app)
3475 | return;
3476 | init();
3477 | if (devtoolsState.highPerfModeEnabled)
3478 | return;
3479 | devtoolsContext.hooks.callHook("routerInfoUpdated", { state: target[ROUTER_INFO_KEY] });
3480 | }, 200));
3481 | }
3482 | function createDevToolsApi(hooks2) {
3483 | return {
3484 | // get inspector tree
3485 | async getInspectorTree(payload) {
3486 | const _payload = {
3487 | ...payload,
3488 | app: activeAppRecord.value.app,
3489 | rootNodes: []
3490 | };
3491 | await new Promise((resolve) => {
3492 | hooks2.callHookWith(
3493 | async (callbacks) => {
3494 | await Promise.all(callbacks.map((cb) => cb(_payload)));
3495 | resolve();
3496 | },
3497 | "getInspectorTree"
3498 | /* GET_INSPECTOR_TREE */
3499 | );
3500 | });
3501 | return _payload.rootNodes;
3502 | },
3503 | // get inspector state
3504 | async getInspectorState(payload) {
3505 | const _payload = {
3506 | ...payload,
3507 | app: activeAppRecord.value.app,
3508 | state: null
3509 | };
3510 | const ctx = {
3511 | currentTab: `custom-inspector:${payload.inspectorId}`
3512 | };
3513 | await new Promise((resolve) => {
3514 | hooks2.callHookWith(
3515 | async (callbacks) => {
3516 | await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
3517 | resolve();
3518 | },
3519 | "getInspectorState"
3520 | /* GET_INSPECTOR_STATE */
3521 | );
3522 | });
3523 | return _payload.state;
3524 | },
3525 | // edit inspector state
3526 | editInspectorState(payload) {
3527 | const stateEditor2 = new StateEditor();
3528 | const _payload = {
3529 | ...payload,
3530 | app: activeAppRecord.value.app,
3531 | set: (obj, path = payload.path, value = payload.state.value, cb) => {
3532 | stateEditor2.set(obj, path, value, cb || stateEditor2.createDefaultSetCallback(payload.state));
3533 | }
3534 | };
3535 | hooks2.callHookWith(
3536 | (callbacks) => {
3537 | callbacks.forEach((cb) => cb(_payload));
3538 | },
3539 | "editInspectorState"
3540 | /* EDIT_INSPECTOR_STATE */
3541 | );
3542 | },
3543 | // send inspector state
3544 | sendInspectorState(inspectorId) {
3545 | const inspector = getInspector(inspectorId);
3546 | hooks2.callHook("sendInspectorState", { inspectorId, plugin: {
3547 | descriptor: inspector.descriptor,
3548 | setupFn: () => ({})
3549 | } });
3550 | },
3551 | // inspect component inspector
3552 | inspectComponentInspector() {
3553 | return inspectComponentHighLighter();
3554 | },
3555 | // cancel inspect component inspector
3556 | cancelInspectComponentInspector() {
3557 | return cancelInspectComponentHighLighter();
3558 | },
3559 | // get component render code
3560 | getComponentRenderCode(id) {
3561 | const instance = getComponentInstance(activeAppRecord.value, id);
3562 | if (instance)
3563 | return !(typeof (instance == null ? void 0 : instance.type) === "function") ? instance.render.toString() : instance.type.toString();
3564 | },
3565 | // scroll to component
3566 | scrollToComponent(id) {
3567 | return scrollToComponent({ id });
3568 | },
3569 | // open in editor
3570 | openInEditor,
3571 | // get vue inspector
3572 | getVueInspector: getComponentInspector,
3573 | // toggle app
3574 | toggleApp(id, options) {
3575 | const appRecord = devtoolsAppRecords.value.find((record) => record.id === id);
3576 | if (appRecord) {
3577 | setActiveAppRecordId(id);
3578 | setActiveAppRecord(appRecord);
3579 | normalizeRouterInfo(appRecord, activeAppRecord);
3580 | callInspectorUpdatedHook();
3581 | registerDevToolsPlugin(appRecord.app, options);
3582 | }
3583 | },
3584 | // inspect dom
3585 | inspectDOM(instanceId) {
3586 | const instance = getComponentInstance(activeAppRecord.value, instanceId);
3587 | if (instance) {
3588 | const [el] = getRootElementsFromComponentInstance(instance);
3589 | if (el) {
3590 | target.__VUE_DEVTOOLS_INSPECT_DOM_TARGET__ = el;
3591 | }
3592 | }
3593 | },
3594 | updatePluginSettings(pluginId, key, value) {
3595 | setPluginSettings(pluginId, key, value);
3596 | },
3597 | getPluginSettings(pluginId) {
3598 | return {
3599 | options: getPluginSettingsOptions(pluginId),
3600 | values: getPluginSettings(pluginId)
3601 | };
3602 | }
3603 | };
3604 | }
3605 | init_esm_shims2();
3606 | var _a15;
3607 | var _b15;
3608 | (_b15 = (_a15 = target).__VUE_DEVTOOLS_ENV__) != null ? _b15 : _a15.__VUE_DEVTOOLS_ENV__ = {
3609 | vitePluginDetected: false
3610 | };
3611 | var hooks = createDevToolsCtxHooks();
3612 | var _a16;
3613 | var _b16;
3614 | (_b16 = (_a16 = target).__VUE_DEVTOOLS_KIT_CONTEXT__) != null ? _b16 : _a16.__VUE_DEVTOOLS_KIT_CONTEXT__ = {
3615 | hooks,
3616 | get state() {
3617 | return {
3618 | ...devtoolsState,
3619 | activeAppRecordId: activeAppRecord.id,
3620 | activeAppRecord: activeAppRecord.value,
3621 | appRecords: devtoolsAppRecords.value
3622 | };
3623 | },
3624 | api: createDevToolsApi(hooks)
3625 | };
3626 | var devtoolsContext = target.__VUE_DEVTOOLS_KIT_CONTEXT__;
3627 | init_esm_shims2();
3628 | var import_speakingurl = __toESM2(require_speakingurl2(), 1);
3629 | var _a17;
3630 | var _b17;
3631 | var appRecordInfo = (_b17 = (_a17 = target).__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__) != null ? _b17 : _a17.__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__ = {
3632 | id: 0,
3633 | appIds: /* @__PURE__ */ new Set()
3634 | };
3635 | init_esm_shims2();
3636 | function onDevToolsClientConnected(fn) {
3637 | return new Promise((resolve) => {
3638 | if (devtoolsState.connected && devtoolsState.clientConnected) {
3639 | fn();
3640 | resolve();
3641 | return;
3642 | }
3643 | devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
3644 | if (state.connected && state.clientConnected) {
3645 | fn();
3646 | resolve();
3647 | }
3648 | });
3649 | });
3650 | }
3651 | init_esm_shims2();
3652 | function toggleHighPerfMode(state) {
3653 | devtoolsState.highPerfModeEnabled = state != null ? state : !devtoolsState.highPerfModeEnabled;
3654 | if (!state && activeAppRecord.value) {
3655 | registerDevToolsPlugin(activeAppRecord.value.app);
3656 | }
3657 | }
3658 | init_esm_shims2();
3659 | init_esm_shims2();
3660 | init_esm_shims2();
3661 | function updateDevToolsClientDetected(params) {
3662 | devtoolsState.devtoolsClientDetected = {
3663 | ...devtoolsState.devtoolsClientDetected,
3664 | ...params
3665 | };
3666 | const devtoolsClientVisible = Object.values(devtoolsState.devtoolsClientDetected).some(Boolean);
3667 | toggleHighPerfMode(!devtoolsClientVisible);
3668 | }
3669 | var _a18;
3670 | var _b18;
3671 | (_b18 = (_a18 = target).__VUE_DEVTOOLS_UPDATE_CLIENT_DETECTED__) != null ? _b18 : _a18.__VUE_DEVTOOLS_UPDATE_CLIENT_DETECTED__ = updateDevToolsClientDetected;
3672 | init_esm_shims2();
3673 | init_esm_shims2();
3674 | init_esm_shims2();
3675 | init_esm_shims2();
3676 | init_esm_shims2();
3677 | init_esm_shims2();
3678 | init_esm_shims2();
3679 | var DoubleIndexedKV = class {
3680 | constructor() {
3681 | this.keyToValue = /* @__PURE__ */ new Map();
3682 | this.valueToKey = /* @__PURE__ */ new Map();
3683 | }
3684 | set(key, value) {
3685 | this.keyToValue.set(key, value);
3686 | this.valueToKey.set(value, key);
3687 | }
3688 | getByKey(key) {
3689 | return this.keyToValue.get(key);
3690 | }
3691 | getByValue(value) {
3692 | return this.valueToKey.get(value);
3693 | }
3694 | clear() {
3695 | this.keyToValue.clear();
3696 | this.valueToKey.clear();
3697 | }
3698 | };
3699 | var Registry = class {
3700 | constructor(generateIdentifier) {
3701 | this.generateIdentifier = generateIdentifier;
3702 | this.kv = new DoubleIndexedKV();
3703 | }
3704 | register(value, identifier) {
3705 | if (this.kv.getByValue(value)) {
3706 | return;
3707 | }
3708 | if (!identifier) {
3709 | identifier = this.generateIdentifier(value);
3710 | }
3711 | this.kv.set(identifier, value);
3712 | }
3713 | clear() {
3714 | this.kv.clear();
3715 | }
3716 | getIdentifier(value) {
3717 | return this.kv.getByValue(value);
3718 | }
3719 | getValue(identifier) {
3720 | return this.kv.getByKey(identifier);
3721 | }
3722 | };
3723 | var ClassRegistry = class extends Registry {
3724 | constructor() {
3725 | super((c) => c.name);
3726 | this.classToAllowedProps = /* @__PURE__ */ new Map();
3727 | }
3728 | register(value, options) {
3729 | if (typeof options === "object") {
3730 | if (options.allowProps) {
3731 | this.classToAllowedProps.set(value, options.allowProps);
3732 | }
3733 | super.register(value, options.identifier);
3734 | } else {
3735 | super.register(value, options);
3736 | }
3737 | }
3738 | getAllowedProps(value) {
3739 | return this.classToAllowedProps.get(value);
3740 | }
3741 | };
3742 | init_esm_shims2();
3743 | init_esm_shims2();
3744 | function valuesOfObj(record) {
3745 | if ("values" in Object) {
3746 | return Object.values(record);
3747 | }
3748 | const values = [];
3749 | for (const key in record) {
3750 | if (record.hasOwnProperty(key)) {
3751 | values.push(record[key]);
3752 | }
3753 | }
3754 | return values;
3755 | }
3756 | function find(record, predicate) {
3757 | const values = valuesOfObj(record);
3758 | if ("find" in values) {
3759 | return values.find(predicate);
3760 | }
3761 | const valuesNotNever = values;
3762 | for (let i = 0; i < valuesNotNever.length; i++) {
3763 | const value = valuesNotNever[i];
3764 | if (predicate(value)) {
3765 | return value;
3766 | }
3767 | }
3768 | return void 0;
3769 | }
3770 | function forEach(record, run) {
3771 | Object.entries(record).forEach(([key, value]) => run(value, key));
3772 | }
3773 | function includes(arr, value) {
3774 | return arr.indexOf(value) !== -1;
3775 | }
3776 | function findArr(record, predicate) {
3777 | for (let i = 0; i < record.length; i++) {
3778 | const value = record[i];
3779 | if (predicate(value)) {
3780 | return value;
3781 | }
3782 | }
3783 | return void 0;
3784 | }
3785 | var CustomTransformerRegistry = class {
3786 | constructor() {
3787 | this.transfomers = {};
3788 | }
3789 | register(transformer) {
3790 | this.transfomers[transformer.name] = transformer;
3791 | }
3792 | findApplicable(v) {
3793 | return find(this.transfomers, (transformer) => transformer.isApplicable(v));
3794 | }
3795 | findByName(name) {
3796 | return this.transfomers[name];
3797 | }
3798 | };
3799 | init_esm_shims2();
3800 | init_esm_shims2();
3801 | var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
3802 | var isUndefined = (payload) => typeof payload === "undefined";
3803 | var isNull = (payload) => payload === null;
3804 | var isPlainObject2 = (payload) => {
3805 | if (typeof payload !== "object" || payload === null)
3806 | return false;
3807 | if (payload === Object.prototype)
3808 | return false;
3809 | if (Object.getPrototypeOf(payload) === null)
3810 | return true;
3811 | return Object.getPrototypeOf(payload) === Object.prototype;
3812 | };
3813 | var isEmptyObject = (payload) => isPlainObject2(payload) && Object.keys(payload).length === 0;
3814 | var isArray = (payload) => Array.isArray(payload);
3815 | var isString = (payload) => typeof payload === "string";
3816 | var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
3817 | var isBoolean = (payload) => typeof payload === "boolean";
3818 | var isRegExp = (payload) => payload instanceof RegExp;
3819 | var isMap = (payload) => payload instanceof Map;
3820 | var isSet = (payload) => payload instanceof Set;
3821 | var isSymbol = (payload) => getType(payload) === "Symbol";
3822 | var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
3823 | var isError = (payload) => payload instanceof Error;
3824 | var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
3825 | var isPrimitive2 = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
3826 | var isBigint = (payload) => typeof payload === "bigint";
3827 | var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
3828 | var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
3829 | var isURL = (payload) => payload instanceof URL;
3830 | init_esm_shims2();
3831 | var escapeKey = (key) => key.replace(/\./g, "\\.");
3832 | var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
3833 | var parsePath = (string) => {
3834 | const result = [];
3835 | let segment = "";
3836 | for (let i = 0; i < string.length; i++) {
3837 | let char = string.charAt(i);
3838 | const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
3839 | if (isEscapedDot) {
3840 | segment += ".";
3841 | i++;
3842 | continue;
3843 | }
3844 | const isEndOfSegment = char === ".";
3845 | if (isEndOfSegment) {
3846 | result.push(segment);
3847 | segment = "";
3848 | continue;
3849 | }
3850 | segment += char;
3851 | }
3852 | const lastSegment = segment;
3853 | result.push(lastSegment);
3854 | return result;
3855 | };
3856 | init_esm_shims2();
3857 | function simpleTransformation(isApplicable, annotation, transform, untransform) {
3858 | return {
3859 | isApplicable,
3860 | annotation,
3861 | transform,
3862 | untransform
3863 | };
3864 | }
3865 | var simpleRules = [
3866 | simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
3867 | simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
3868 | if (typeof BigInt !== "undefined") {
3869 | return BigInt(v);
3870 | }
3871 | console.error("Please add a BigInt polyfill.");
3872 | return v;
3873 | }),
3874 | simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
3875 | simpleTransformation(isError, "Error", (v, superJson) => {
3876 | const baseError = {
3877 | name: v.name,
3878 | message: v.message
3879 | };
3880 | superJson.allowedErrorProps.forEach((prop) => {
3881 | baseError[prop] = v[prop];
3882 | });
3883 | return baseError;
3884 | }, (v, superJson) => {
3885 | const e = new Error(v.message);
3886 | e.name = v.name;
3887 | e.stack = v.stack;
3888 | superJson.allowedErrorProps.forEach((prop) => {
3889 | e[prop] = v[prop];
3890 | });
3891 | return e;
3892 | }),
3893 | simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
3894 | const body = regex.slice(1, regex.lastIndexOf("/"));
3895 | const flags = regex.slice(regex.lastIndexOf("/") + 1);
3896 | return new RegExp(body, flags);
3897 | }),
3898 | simpleTransformation(
3899 | isSet,
3900 | "set",
3901 | // (sets only exist in es6+)
3902 | // eslint-disable-next-line es5/no-es6-methods
3903 | (v) => [...v.values()],
3904 | (v) => new Set(v)
3905 | ),
3906 | simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
3907 | simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
3908 | if (isNaNValue(v)) {
3909 | return "NaN";
3910 | }
3911 | if (v > 0) {
3912 | return "Infinity";
3913 | } else {
3914 | return "-Infinity";
3915 | }
3916 | }, Number),
3917 | simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
3918 | return "-0";
3919 | }, Number),
3920 | simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
3921 | ];
3922 | function compositeTransformation(isApplicable, annotation, transform, untransform) {
3923 | return {
3924 | isApplicable,
3925 | annotation,
3926 | transform,
3927 | untransform
3928 | };
3929 | }
3930 | var symbolRule = compositeTransformation((s, superJson) => {
3931 | if (isSymbol(s)) {
3932 | const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
3933 | return isRegistered;
3934 | }
3935 | return false;
3936 | }, (s, superJson) => {
3937 | const identifier = superJson.symbolRegistry.getIdentifier(s);
3938 | return ["symbol", identifier];
3939 | }, (v) => v.description, (_, a, superJson) => {
3940 | const value = superJson.symbolRegistry.getValue(a[1]);
3941 | if (!value) {
3942 | throw new Error("Trying to deserialize unknown symbol");
3943 | }
3944 | return value;
3945 | });
3946 | var constructorToName = [
3947 | Int8Array,
3948 | Uint8Array,
3949 | Int16Array,
3950 | Uint16Array,
3951 | Int32Array,
3952 | Uint32Array,
3953 | Float32Array,
3954 | Float64Array,
3955 | Uint8ClampedArray
3956 | ].reduce((obj, ctor) => {
3957 | obj[ctor.name] = ctor;
3958 | return obj;
3959 | }, {});
3960 | var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
3961 | const ctor = constructorToName[a[1]];
3962 | if (!ctor) {
3963 | throw new Error("Trying to deserialize unknown typed array");
3964 | }
3965 | return new ctor(v);
3966 | });
3967 | function isInstanceOfRegisteredClass(potentialClass, superJson) {
3968 | if (potentialClass == null ? void 0 : potentialClass.constructor) {
3969 | const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
3970 | return isRegistered;
3971 | }
3972 | return false;
3973 | }
3974 | var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
3975 | const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
3976 | return ["class", identifier];
3977 | }, (clazz, superJson) => {
3978 | const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
3979 | if (!allowedProps) {
3980 | return { ...clazz };
3981 | }
3982 | const result = {};
3983 | allowedProps.forEach((prop) => {
3984 | result[prop] = clazz[prop];
3985 | });
3986 | return result;
3987 | }, (v, a, superJson) => {
3988 | const clazz = superJson.classRegistry.getValue(a[1]);
3989 | if (!clazz) {
3990 | throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
3991 | }
3992 | return Object.assign(Object.create(clazz.prototype), v);
3993 | });
3994 | var customRule = compositeTransformation((value, superJson) => {
3995 | return !!superJson.customTransformerRegistry.findApplicable(value);
3996 | }, (value, superJson) => {
3997 | const transformer = superJson.customTransformerRegistry.findApplicable(value);
3998 | return ["custom", transformer.name];
3999 | }, (value, superJson) => {
4000 | const transformer = superJson.customTransformerRegistry.findApplicable(value);
4001 | return transformer.serialize(value);
4002 | }, (v, a, superJson) => {
4003 | const transformer = superJson.customTransformerRegistry.findByName(a[1]);
4004 | if (!transformer) {
4005 | throw new Error("Trying to deserialize unknown custom value");
4006 | }
4007 | return transformer.deserialize(v);
4008 | });
4009 | var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
4010 | var transformValue = (value, superJson) => {
4011 | const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
4012 | if (applicableCompositeRule) {
4013 | return {
4014 | value: applicableCompositeRule.transform(value, superJson),
4015 | type: applicableCompositeRule.annotation(value, superJson)
4016 | };
4017 | }
4018 | const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
4019 | if (applicableSimpleRule) {
4020 | return {
4021 | value: applicableSimpleRule.transform(value, superJson),
4022 | type: applicableSimpleRule.annotation
4023 | };
4024 | }
4025 | return void 0;
4026 | };
4027 | var simpleRulesByAnnotation = {};
4028 | simpleRules.forEach((rule) => {
4029 | simpleRulesByAnnotation[rule.annotation] = rule;
4030 | });
4031 | var untransformValue = (json, type, superJson) => {
4032 | if (isArray(type)) {
4033 | switch (type[0]) {
4034 | case "symbol":
4035 | return symbolRule.untransform(json, type, superJson);
4036 | case "class":
4037 | return classRule.untransform(json, type, superJson);
4038 | case "custom":
4039 | return customRule.untransform(json, type, superJson);
4040 | case "typed-array":
4041 | return typedArrayRule.untransform(json, type, superJson);
4042 | default:
4043 | throw new Error("Unknown transformation: " + type);
4044 | }
4045 | } else {
4046 | const transformation = simpleRulesByAnnotation[type];
4047 | if (!transformation) {
4048 | throw new Error("Unknown transformation: " + type);
4049 | }
4050 | return transformation.untransform(json, superJson);
4051 | }
4052 | };
4053 | init_esm_shims2();
4054 | var getNthKey = (value, n) => {
4055 | if (n > value.size)
4056 | throw new Error("index out of bounds");
4057 | const keys = value.keys();
4058 | while (n > 0) {
4059 | keys.next();
4060 | n--;
4061 | }
4062 | return keys.next().value;
4063 | };
4064 | function validatePath(path) {
4065 | if (includes(path, "__proto__")) {
4066 | throw new Error("__proto__ is not allowed as a property");
4067 | }
4068 | if (includes(path, "prototype")) {
4069 | throw new Error("prototype is not allowed as a property");
4070 | }
4071 | if (includes(path, "constructor")) {
4072 | throw new Error("constructor is not allowed as a property");
4073 | }
4074 | }
4075 | var getDeep = (object, path) => {
4076 | validatePath(path);
4077 | for (let i = 0; i < path.length; i++) {
4078 | const key = path[i];
4079 | if (isSet(object)) {
4080 | object = getNthKey(object, +key);
4081 | } else if (isMap(object)) {
4082 | const row = +key;
4083 | const type = +path[++i] === 0 ? "key" : "value";
4084 | const keyOfRow = getNthKey(object, row);
4085 | switch (type) {
4086 | case "key":
4087 | object = keyOfRow;
4088 | break;
4089 | case "value":
4090 | object = object.get(keyOfRow);
4091 | break;
4092 | }
4093 | } else {
4094 | object = object[key];
4095 | }
4096 | }
4097 | return object;
4098 | };
4099 | var setDeep = (object, path, mapper) => {
4100 | validatePath(path);
4101 | if (path.length === 0) {
4102 | return mapper(object);
4103 | }
4104 | let parent = object;
4105 | for (let i = 0; i < path.length - 1; i++) {
4106 | const key = path[i];
4107 | if (isArray(parent)) {
4108 | const index = +key;
4109 | parent = parent[index];
4110 | } else if (isPlainObject2(parent)) {
4111 | parent = parent[key];
4112 | } else if (isSet(parent)) {
4113 | const row = +key;
4114 | parent = getNthKey(parent, row);
4115 | } else if (isMap(parent)) {
4116 | const isEnd = i === path.length - 2;
4117 | if (isEnd) {
4118 | break;
4119 | }
4120 | const row = +key;
4121 | const type = +path[++i] === 0 ? "key" : "value";
4122 | const keyOfRow = getNthKey(parent, row);
4123 | switch (type) {
4124 | case "key":
4125 | parent = keyOfRow;
4126 | break;
4127 | case "value":
4128 | parent = parent.get(keyOfRow);
4129 | break;
4130 | }
4131 | }
4132 | }
4133 | const lastKey = path[path.length - 1];
4134 | if (isArray(parent)) {
4135 | parent[+lastKey] = mapper(parent[+lastKey]);
4136 | } else if (isPlainObject2(parent)) {
4137 | parent[lastKey] = mapper(parent[lastKey]);
4138 | }
4139 | if (isSet(parent)) {
4140 | const oldValue = getNthKey(parent, +lastKey);
4141 | const newValue = mapper(oldValue);
4142 | if (oldValue !== newValue) {
4143 | parent.delete(oldValue);
4144 | parent.add(newValue);
4145 | }
4146 | }
4147 | if (isMap(parent)) {
4148 | const row = +path[path.length - 2];
4149 | const keyToRow = getNthKey(parent, row);
4150 | const type = +lastKey === 0 ? "key" : "value";
4151 | switch (type) {
4152 | case "key": {
4153 | const newKey = mapper(keyToRow);
4154 | parent.set(newKey, parent.get(keyToRow));
4155 | if (newKey !== keyToRow) {
4156 | parent.delete(keyToRow);
4157 | }
4158 | break;
4159 | }
4160 | case "value": {
4161 | parent.set(keyToRow, mapper(parent.get(keyToRow)));
4162 | break;
4163 | }
4164 | }
4165 | }
4166 | return object;
4167 | };
4168 | function traverse(tree, walker2, origin = []) {
4169 | if (!tree) {
4170 | return;
4171 | }
4172 | if (!isArray(tree)) {
4173 | forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
4174 | return;
4175 | }
4176 | const [nodeValue, children] = tree;
4177 | if (children) {
4178 | forEach(children, (child, key) => {
4179 | traverse(child, walker2, [...origin, ...parsePath(key)]);
4180 | });
4181 | }
4182 | walker2(nodeValue, origin);
4183 | }
4184 | function applyValueAnnotations(plain, annotations, superJson) {
4185 | traverse(annotations, (type, path) => {
4186 | plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
4187 | });
4188 | return plain;
4189 | }
4190 | function applyReferentialEqualityAnnotations(plain, annotations) {
4191 | function apply(identicalPaths, path) {
4192 | const object = getDeep(plain, parsePath(path));
4193 | identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
4194 | plain = setDeep(plain, identicalObjectPath, () => object);
4195 | });
4196 | }
4197 | if (isArray(annotations)) {
4198 | const [root, other] = annotations;
4199 | root.forEach((identicalPath) => {
4200 | plain = setDeep(plain, parsePath(identicalPath), () => plain);
4201 | });
4202 | if (other) {
4203 | forEach(other, apply);
4204 | }
4205 | } else {
4206 | forEach(annotations, apply);
4207 | }
4208 | return plain;
4209 | }
4210 | var isDeep = (object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
4211 | function addIdentity(object, path, identities) {
4212 | const existingSet = identities.get(object);
4213 | if (existingSet) {
4214 | existingSet.push(path);
4215 | } else {
4216 | identities.set(object, [path]);
4217 | }
4218 | }
4219 | function generateReferentialEqualityAnnotations(identitites, dedupe) {
4220 | const result = {};
4221 | let rootEqualityPaths = void 0;
4222 | identitites.forEach((paths) => {
4223 | if (paths.length <= 1) {
4224 | return;
4225 | }
4226 | if (!dedupe) {
4227 | paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
4228 | }
4229 | const [representativePath, ...identicalPaths] = paths;
4230 | if (representativePath.length === 0) {
4231 | rootEqualityPaths = identicalPaths.map(stringifyPath);
4232 | } else {
4233 | result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
4234 | }
4235 | });
4236 | if (rootEqualityPaths) {
4237 | if (isEmptyObject(result)) {
4238 | return [rootEqualityPaths];
4239 | } else {
4240 | return [rootEqualityPaths, result];
4241 | }
4242 | } else {
4243 | return isEmptyObject(result) ? void 0 : result;
4244 | }
4245 | }
4246 | var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
4247 | var _a25;
4248 | const primitive = isPrimitive2(object);
4249 | if (!primitive) {
4250 | addIdentity(object, path, identities);
4251 | const seen = seenObjects.get(object);
4252 | if (seen) {
4253 | return dedupe ? {
4254 | transformedValue: null
4255 | } : seen;
4256 | }
4257 | }
4258 | if (!isDeep(object, superJson)) {
4259 | const transformed2 = transformValue(object, superJson);
4260 | const result2 = transformed2 ? {
4261 | transformedValue: transformed2.value,
4262 | annotations: [transformed2.type]
4263 | } : {
4264 | transformedValue: object
4265 | };
4266 | if (!primitive) {
4267 | seenObjects.set(object, result2);
4268 | }
4269 | return result2;
4270 | }
4271 | if (includes(objectsInThisPath, object)) {
4272 | return {
4273 | transformedValue: null
4274 | };
4275 | }
4276 | const transformationResult = transformValue(object, superJson);
4277 | const transformed = (_a25 = transformationResult == null ? void 0 : transformationResult.value) != null ? _a25 : object;
4278 | const transformedValue = isArray(transformed) ? [] : {};
4279 | const innerAnnotations = {};
4280 | forEach(transformed, (value, index) => {
4281 | if (index === "__proto__" || index === "constructor" || index === "prototype") {
4282 | throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
4283 | }
4284 | const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
4285 | transformedValue[index] = recursiveResult.transformedValue;
4286 | if (isArray(recursiveResult.annotations)) {
4287 | innerAnnotations[index] = recursiveResult.annotations;
4288 | } else if (isPlainObject2(recursiveResult.annotations)) {
4289 | forEach(recursiveResult.annotations, (tree, key) => {
4290 | innerAnnotations[escapeKey(index) + "." + key] = tree;
4291 | });
4292 | }
4293 | });
4294 | const result = isEmptyObject(innerAnnotations) ? {
4295 | transformedValue,
4296 | annotations: !!transformationResult ? [transformationResult.type] : void 0
4297 | } : {
4298 | transformedValue,
4299 | annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
4300 | };
4301 | if (!primitive) {
4302 | seenObjects.set(object, result);
4303 | }
4304 | return result;
4305 | };
4306 | init_esm_shims2();
4307 | init_esm_shims2();
4308 | function getType2(payload) {
4309 | return Object.prototype.toString.call(payload).slice(8, -1);
4310 | }
4311 | function isArray2(payload) {
4312 | return getType2(payload) === "Array";
4313 | }
4314 | function isPlainObject3(payload) {
4315 | if (getType2(payload) !== "Object")
4316 | return false;
4317 | const prototype = Object.getPrototypeOf(payload);
4318 | return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
4319 | }
4320 | function isNull2(payload) {
4321 | return getType2(payload) === "Null";
4322 | }
4323 | function isOneOf(a, b, c, d, e) {
4324 | return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
4325 | }
4326 | function isUndefined2(payload) {
4327 | return getType2(payload) === "Undefined";
4328 | }
4329 | var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
4330 | function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
4331 | const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
4332 | if (propType === "enumerable")
4333 | carry[key] = newVal;
4334 | if (includeNonenumerable && propType === "nonenumerable") {
4335 | Object.defineProperty(carry, key, {
4336 | value: newVal,
4337 | enumerable: false,
4338 | writable: true,
4339 | configurable: true
4340 | });
4341 | }
4342 | }
4343 | function copy(target22, options = {}) {
4344 | if (isArray2(target22)) {
4345 | return target22.map((item) => copy(item, options));
4346 | }
4347 | if (!isPlainObject3(target22)) {
4348 | return target22;
4349 | }
4350 | const props = Object.getOwnPropertyNames(target22);
4351 | const symbols = Object.getOwnPropertySymbols(target22);
4352 | return [...props, ...symbols].reduce((carry, key) => {
4353 | if (isArray2(options.props) && !options.props.includes(key)) {
4354 | return carry;
4355 | }
4356 | const val = target22[key];
4357 | const newVal = copy(val, options);
4358 | assignProp(carry, key, newVal, target22, options.nonenumerable);
4359 | return carry;
4360 | }, {});
4361 | }
4362 | var SuperJSON = class {
4363 | /**
4364 | * @param dedupeReferentialEqualities If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
4365 | */
4366 | constructor({ dedupe = false } = {}) {
4367 | this.classRegistry = new ClassRegistry();
4368 | this.symbolRegistry = new Registry((s) => {
4369 | var _a25;
4370 | return (_a25 = s.description) != null ? _a25 : "";
4371 | });
4372 | this.customTransformerRegistry = new CustomTransformerRegistry();
4373 | this.allowedErrorProps = [];
4374 | this.dedupe = dedupe;
4375 | }
4376 | serialize(object) {
4377 | const identities = /* @__PURE__ */ new Map();
4378 | const output = walker(object, identities, this, this.dedupe);
4379 | const res = {
4380 | json: output.transformedValue
4381 | };
4382 | if (output.annotations) {
4383 | res.meta = {
4384 | ...res.meta,
4385 | values: output.annotations
4386 | };
4387 | }
4388 | const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
4389 | if (equalityAnnotations) {
4390 | res.meta = {
4391 | ...res.meta,
4392 | referentialEqualities: equalityAnnotations
4393 | };
4394 | }
4395 | return res;
4396 | }
4397 | deserialize(payload) {
4398 | const { json, meta } = payload;
4399 | let result = copy(json);
4400 | if (meta == null ? void 0 : meta.values) {
4401 | result = applyValueAnnotations(result, meta.values, this);
4402 | }
4403 | if (meta == null ? void 0 : meta.referentialEqualities) {
4404 | result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
4405 | }
4406 | return result;
4407 | }
4408 | stringify(object) {
4409 | return JSON.stringify(this.serialize(object));
4410 | }
4411 | parse(string) {
4412 | return this.deserialize(JSON.parse(string));
4413 | }
4414 | registerClass(v, options) {
4415 | this.classRegistry.register(v, options);
4416 | }
4417 | registerSymbol(v, identifier) {
4418 | this.symbolRegistry.register(v, identifier);
4419 | }
4420 | registerCustom(transformer, name) {
4421 | this.customTransformerRegistry.register({
4422 | name,
4423 | ...transformer
4424 | });
4425 | }
4426 | allowErrorProps(...props) {
4427 | this.allowedErrorProps.push(...props);
4428 | }
4429 | };
4430 | SuperJSON.defaultInstance = new SuperJSON();
4431 | SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
4432 | SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
4433 | SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
4434 | SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
4435 | SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
4436 | SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
4437 | SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
4438 | SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
4439 | var serialize = SuperJSON.serialize;
4440 | var deserialize = SuperJSON.deserialize;
4441 | var stringify = SuperJSON.stringify;
4442 | var parse = SuperJSON.parse;
4443 | var registerClass = SuperJSON.registerClass;
4444 | var registerCustom = SuperJSON.registerCustom;
4445 | var registerSymbol = SuperJSON.registerSymbol;
4446 | var allowErrorProps = SuperJSON.allowErrorProps;
4447 | init_esm_shims2();
4448 | init_esm_shims2();
4449 | init_esm_shims2();
4450 | init_esm_shims2();
4451 | init_esm_shims2();
4452 | init_esm_shims2();
4453 | init_esm_shims2();
4454 | init_esm_shims2();
4455 | init_esm_shims2();
4456 | init_esm_shims2();
4457 | init_esm_shims2();
4458 | init_esm_shims2();
4459 | init_esm_shims2();
4460 | init_esm_shims2();
4461 | init_esm_shims2();
4462 | init_esm_shims2();
4463 | init_esm_shims2();
4464 | init_esm_shims2();
4465 | init_esm_shims2();
4466 | init_esm_shims2();
4467 | init_esm_shims2();
4468 | init_esm_shims2();
4469 | init_esm_shims2();
4470 | var _a19;
4471 | var _b19;
4472 | (_b19 = (_a19 = target).__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__) != null ? _b19 : _a19.__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__ = [];
4473 | var _a20;
4474 | var _b20;
4475 | (_b20 = (_a20 = target).__VUE_DEVTOOLS_KIT_RPC_CLIENT__) != null ? _b20 : _a20.__VUE_DEVTOOLS_KIT_RPC_CLIENT__ = null;
4476 | var _a21;
4477 | var _b21;
4478 | (_b21 = (_a21 = target).__VUE_DEVTOOLS_KIT_RPC_SERVER__) != null ? _b21 : _a21.__VUE_DEVTOOLS_KIT_RPC_SERVER__ = null;
4479 | var _a222;
4480 | var _b22;
4481 | (_b22 = (_a222 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__) != null ? _b22 : _a222.__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__ = null;
4482 | var _a23;
4483 | var _b23;
4484 | (_b23 = (_a23 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__) != null ? _b23 : _a23.__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__ = null;
4485 | var _a24;
4486 | var _b24;
4487 | (_b24 = (_a24 = target).__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__) != null ? _b24 : _a24.__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__ = null;
4488 | init_esm_shims2();
4489 | init_esm_shims2();
4490 | init_esm_shims2();
4491 | init_esm_shims2();
4492 | init_esm_shims2();
4493 | init_esm_shims2();
4494 | init_esm_shims2();
4495 | var MAX_SERIALIZED_SIZE = 2 * 1024 * 1024;
4496 | export {
4497 | addCustomCommand,
4498 | addCustomTab,
4499 | onDevToolsClientConnected,
4500 | onDevToolsConnected,
4501 | removeCustomCommand,
4502 | setupDevToolsPlugin,
4503 | setupDevToolsPlugin as setupDevtoolsPlugin
4504 | };
4505 | //# sourceMappingURL=vitepress___@vue_devtools-api.js.map
4506 |
```