This is page 6 of 8. Use http://codebase.md/jakedismo/master-mcp-server?lines=false&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
// node_modules/@vue/devtools-shared/dist/index.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
mod
));
var init_esm_shims = __esm({
"../../node_modules/.pnpm/[email protected]_@[email protected]_@[email protected][email protected][email protected]_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js"() {
"use strict";
}
});
var require_rfdc = __commonJS({
"../../node_modules/.pnpm/[email protected]/node_modules/rfdc/index.js"(exports, module) {
"use strict";
init_esm_shims();
module.exports = rfdc2;
function copyBuffer(cur) {
if (cur instanceof Buffer) {
return Buffer.from(cur);
}
return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
}
function rfdc2(opts) {
opts = opts || {};
if (opts.circles) return rfdcCircles(opts);
const constructorHandlers = /* @__PURE__ */ new Map();
constructorHandlers.set(Date, (o) => new Date(o));
constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
if (opts.constructorHandlers) {
for (const handler2 of opts.constructorHandlers) {
constructorHandlers.set(handler2[0], handler2[1]);
}
}
let handler = null;
return opts.proto ? cloneProto : clone;
function cloneArray(a, fn) {
const keys = Object.keys(a);
const a2 = new Array(keys.length);
for (let i = 0; i < keys.length; i++) {
const k = keys[i];
const cur = a[k];
if (typeof cur !== "object" || cur === null) {
a2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
a2[k] = handler(cur, fn);
} else if (ArrayBuffer.isView(cur)) {
a2[k] = copyBuffer(cur);
} else {
a2[k] = fn(cur);
}
}
return a2;
}
function clone(o) {
if (typeof o !== "object" || o === null) return o;
if (Array.isArray(o)) return cloneArray(o, clone);
if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
return handler(o, clone);
}
const o2 = {};
for (const k in o) {
if (Object.hasOwnProperty.call(o, k) === false) continue;
const cur = o[k];
if (typeof cur !== "object" || cur === null) {
o2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
o2[k] = handler(cur, clone);
} else if (ArrayBuffer.isView(cur)) {
o2[k] = copyBuffer(cur);
} else {
o2[k] = clone(cur);
}
}
return o2;
}
function cloneProto(o) {
if (typeof o !== "object" || o === null) return o;
if (Array.isArray(o)) return cloneArray(o, cloneProto);
if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
return handler(o, cloneProto);
}
const o2 = {};
for (const k in o) {
const cur = o[k];
if (typeof cur !== "object" || cur === null) {
o2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
o2[k] = handler(cur, cloneProto);
} else if (ArrayBuffer.isView(cur)) {
o2[k] = copyBuffer(cur);
} else {
o2[k] = cloneProto(cur);
}
}
return o2;
}
}
function rfdcCircles(opts) {
const refs = [];
const refsNew = [];
const constructorHandlers = /* @__PURE__ */ new Map();
constructorHandlers.set(Date, (o) => new Date(o));
constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
if (opts.constructorHandlers) {
for (const handler2 of opts.constructorHandlers) {
constructorHandlers.set(handler2[0], handler2[1]);
}
}
let handler = null;
return opts.proto ? cloneProto : clone;
function cloneArray(a, fn) {
const keys = Object.keys(a);
const a2 = new Array(keys.length);
for (let i = 0; i < keys.length; i++) {
const k = keys[i];
const cur = a[k];
if (typeof cur !== "object" || cur === null) {
a2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
a2[k] = handler(cur, fn);
} else if (ArrayBuffer.isView(cur)) {
a2[k] = copyBuffer(cur);
} else {
const index = refs.indexOf(cur);
if (index !== -1) {
a2[k] = refsNew[index];
} else {
a2[k] = fn(cur);
}
}
}
return a2;
}
function clone(o) {
if (typeof o !== "object" || o === null) return o;
if (Array.isArray(o)) return cloneArray(o, clone);
if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
return handler(o, clone);
}
const o2 = {};
refs.push(o);
refsNew.push(o2);
for (const k in o) {
if (Object.hasOwnProperty.call(o, k) === false) continue;
const cur = o[k];
if (typeof cur !== "object" || cur === null) {
o2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
o2[k] = handler(cur, clone);
} else if (ArrayBuffer.isView(cur)) {
o2[k] = copyBuffer(cur);
} else {
const i = refs.indexOf(cur);
if (i !== -1) {
o2[k] = refsNew[i];
} else {
o2[k] = clone(cur);
}
}
}
refs.pop();
refsNew.pop();
return o2;
}
function cloneProto(o) {
if (typeof o !== "object" || o === null) return o;
if (Array.isArray(o)) return cloneArray(o, cloneProto);
if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
return handler(o, cloneProto);
}
const o2 = {};
refs.push(o);
refsNew.push(o2);
for (const k in o) {
const cur = o[k];
if (typeof cur !== "object" || cur === null) {
o2[k] = cur;
} else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
o2[k] = handler(cur, cloneProto);
} else if (ArrayBuffer.isView(cur)) {
o2[k] = copyBuffer(cur);
} else {
const i = refs.indexOf(cur);
if (i !== -1) {
o2[k] = refsNew[i];
} else {
o2[k] = cloneProto(cur);
}
}
}
refs.pop();
refsNew.pop();
return o2;
}
}
}
});
init_esm_shims();
init_esm_shims();
init_esm_shims();
var isBrowser = typeof navigator !== "undefined";
var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
var isInIframe = isBrowser && target.self !== target.top;
var _a;
var isInElectron = typeof navigator !== "undefined" && ((_a = navigator.userAgent) == null ? void 0 : _a.toLowerCase().includes("electron"));
var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
init_esm_shims();
var import_rfdc = __toESM(require_rfdc(), 1);
var classifyRE = /(?:^|[-_/])(\w)/g;
function toUpper(_, c) {
return c ? c.toUpperCase() : "";
}
function classify(str) {
return str && `${str}`.replace(classifyRE, toUpper);
}
function basename(filename, ext) {
let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
if (normalizedFilename.endsWith(`index${ext}`)) {
normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
}
const lastSlashIndex = normalizedFilename.lastIndexOf("/");
const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
if (ext) {
const extIndex = baseNameWithExt.lastIndexOf(ext);
return baseNameWithExt.substring(0, extIndex);
}
return "";
}
var HTTP_URL_RE = /^https?:\/\//;
function isUrlString(str) {
return str.startsWith("/") || HTTP_URL_RE.test(str);
}
var deepClone = (0, import_rfdc.default)({ circles: true });
// node_modules/perfect-debounce/dist/index.mjs
var DEBOUNCE_DEFAULTS = {
trailing: true
};
function debounce(fn, wait = 25, options = {}) {
options = { ...DEBOUNCE_DEFAULTS, ...options };
if (!Number.isFinite(wait)) {
throw new TypeError("Expected `wait` to be a finite number");
}
let leadingValue;
let timeout;
let resolveList = [];
let currentPromise;
let trailingArgs;
const applyFn = (_this, args) => {
currentPromise = _applyPromised(fn, _this, args);
currentPromise.finally(() => {
currentPromise = null;
if (options.trailing && trailingArgs && !timeout) {
const promise = applyFn(_this, trailingArgs);
trailingArgs = null;
return promise;
}
});
return currentPromise;
};
return function(...args) {
if (currentPromise) {
if (options.trailing) {
trailingArgs = args;
}
return currentPromise;
}
return new Promise((resolve) => {
const shouldCallNow = !timeout && options.leading;
clearTimeout(timeout);
timeout = setTimeout(() => {
timeout = null;
const promise = options.leading ? leadingValue : applyFn(this, args);
for (const _resolve of resolveList) {
_resolve(promise);
}
resolveList = [];
}, wait);
if (shouldCallNow) {
leadingValue = applyFn(this, args);
resolve(leadingValue);
} else {
resolveList.push(resolve);
}
});
};
}
async function _applyPromised(fn, _this, args) {
return await fn.apply(_this, args);
}
// node_modules/hookable/dist/index.mjs
function flatHooks(configHooks, hooks2 = {}, parentName) {
for (const key in configHooks) {
const subHook = configHooks[key];
const name = parentName ? `${parentName}:${key}` : key;
if (typeof subHook === "object" && subHook !== null) {
flatHooks(subHook, hooks2, name);
} else if (typeof subHook === "function") {
hooks2[name] = subHook;
}
}
return hooks2;
}
var defaultTask = { run: (function_) => function_() };
var _createTask = () => defaultTask;
var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
function serialTaskCaller(hooks2, args) {
const name = args.shift();
const task = createTask(name);
return hooks2.reduce(
(promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
Promise.resolve()
);
}
function parallelTaskCaller(hooks2, args) {
const name = args.shift();
const task = createTask(name);
return Promise.all(hooks2.map((hook2) => task.run(() => hook2(...args))));
}
function callEachWith(callbacks, arg0) {
for (const callback of [...callbacks]) {
callback(arg0);
}
}
var Hookable = class {
constructor() {
this._hooks = {};
this._before = void 0;
this._after = void 0;
this._deprecatedMessages = void 0;
this._deprecatedHooks = {};
this.hook = this.hook.bind(this);
this.callHook = this.callHook.bind(this);
this.callHookWith = this.callHookWith.bind(this);
}
hook(name, function_, options = {}) {
if (!name || typeof function_ !== "function") {
return () => {
};
}
const originalName = name;
let dep;
while (this._deprecatedHooks[name]) {
dep = this._deprecatedHooks[name];
name = dep.to;
}
if (dep && !options.allowDeprecated) {
let message = dep.message;
if (!message) {
message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
}
if (!this._deprecatedMessages) {
this._deprecatedMessages = /* @__PURE__ */ new Set();
}
if (!this._deprecatedMessages.has(message)) {
console.warn(message);
this._deprecatedMessages.add(message);
}
}
if (!function_.name) {
try {
Object.defineProperty(function_, "name", {
get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
configurable: true
});
} catch {
}
}
this._hooks[name] = this._hooks[name] || [];
this._hooks[name].push(function_);
return () => {
if (function_) {
this.removeHook(name, function_);
function_ = void 0;
}
};
}
hookOnce(name, function_) {
let _unreg;
let _function = (...arguments_) => {
if (typeof _unreg === "function") {
_unreg();
}
_unreg = void 0;
_function = void 0;
return function_(...arguments_);
};
_unreg = this.hook(name, _function);
return _unreg;
}
removeHook(name, function_) {
if (this._hooks[name]) {
const index = this._hooks[name].indexOf(function_);
if (index !== -1) {
this._hooks[name].splice(index, 1);
}
if (this._hooks[name].length === 0) {
delete this._hooks[name];
}
}
}
deprecateHook(name, deprecated) {
this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
const _hooks = this._hooks[name] || [];
delete this._hooks[name];
for (const hook2 of _hooks) {
this.hook(name, hook2);
}
}
deprecateHooks(deprecatedHooks) {
Object.assign(this._deprecatedHooks, deprecatedHooks);
for (const name in deprecatedHooks) {
this.deprecateHook(name, deprecatedHooks[name]);
}
}
addHooks(configHooks) {
const hooks2 = flatHooks(configHooks);
const removeFns = Object.keys(hooks2).map(
(key) => this.hook(key, hooks2[key])
);
return () => {
for (const unreg of removeFns.splice(0, removeFns.length)) {
unreg();
}
};
}
removeHooks(configHooks) {
const hooks2 = flatHooks(configHooks);
for (const key in hooks2) {
this.removeHook(key, hooks2[key]);
}
}
removeAllHooks() {
for (const key in this._hooks) {
delete this._hooks[key];
}
}
callHook(name, ...arguments_) {
arguments_.unshift(name);
return this.callHookWith(serialTaskCaller, name, ...arguments_);
}
callHookParallel(name, ...arguments_) {
arguments_.unshift(name);
return this.callHookWith(parallelTaskCaller, name, ...arguments_);
}
callHookWith(caller, name, ...arguments_) {
const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
if (this._before) {
callEachWith(this._before, event);
}
const result = caller(
name in this._hooks ? [...this._hooks[name]] : [],
arguments_
);
if (result instanceof Promise) {
return result.finally(() => {
if (this._after && event) {
callEachWith(this._after, event);
}
});
}
if (this._after && event) {
callEachWith(this._after, event);
}
return result;
}
beforeEach(function_) {
this._before = this._before || [];
this._before.push(function_);
return () => {
if (this._before !== void 0) {
const index = this._before.indexOf(function_);
if (index !== -1) {
this._before.splice(index, 1);
}
}
};
}
afterEach(function_) {
this._after = this._after || [];
this._after.push(function_);
return () => {
if (this._after !== void 0) {
const index = this._after.indexOf(function_);
if (index !== -1) {
this._after.splice(index, 1);
}
}
};
}
};
function createHooks() {
return new Hookable();
}
// node_modules/birpc/dist/index.mjs
var { clearTimeout: clearTimeout2, setTimeout: setTimeout2 } = globalThis;
var random = Math.random.bind(Math);
// node_modules/@vue/devtools-kit/dist/index.js
var __create2 = Object.create;
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __getProtoOf2 = Object.getPrototypeOf;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __esm2 = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
};
var __commonJS2 = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps2 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2(from))
if (!__hasOwnProp2.call(to, key) && key !== except)
__defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2 = (mod, isNodeMode, target22) => (target22 = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp2(target22, "default", { value: mod, enumerable: true }) : target22,
mod
));
var init_esm_shims2 = __esm2({
"../../node_modules/.pnpm/[email protected]_@[email protected]_@[email protected][email protected][email protected]_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js"() {
"use strict";
}
});
var require_speakingurl = __commonJS2({
"../../node_modules/.pnpm/[email protected]/node_modules/speakingurl/lib/speakingurl.js"(exports, module) {
"use strict";
init_esm_shims2();
(function(root) {
"use strict";
var charMap = {
// latin
"À": "A",
"Á": "A",
"Â": "A",
"Ã": "A",
"Ä": "Ae",
"Å": "A",
"Æ": "AE",
"Ç": "C",
"È": "E",
"É": "E",
"Ê": "E",
"Ë": "E",
"Ì": "I",
"Í": "I",
"Î": "I",
"Ï": "I",
"Ð": "D",
"Ñ": "N",
"Ò": "O",
"Ó": "O",
"Ô": "O",
"Õ": "O",
"Ö": "Oe",
"Ő": "O",
"Ø": "O",
"Ù": "U",
"Ú": "U",
"Û": "U",
"Ü": "Ue",
"Ű": "U",
"Ý": "Y",
"Þ": "TH",
"ß": "ss",
"à": "a",
"á": "a",
"â": "a",
"ã": "a",
"ä": "ae",
"å": "a",
"æ": "ae",
"ç": "c",
"è": "e",
"é": "e",
"ê": "e",
"ë": "e",
"ì": "i",
"í": "i",
"î": "i",
"ï": "i",
"ð": "d",
"ñ": "n",
"ò": "o",
"ó": "o",
"ô": "o",
"õ": "o",
"ö": "oe",
"ő": "o",
"ø": "o",
"ù": "u",
"ú": "u",
"û": "u",
"ü": "ue",
"ű": "u",
"ý": "y",
"þ": "th",
"ÿ": "y",
"ẞ": "SS",
// language specific
// Arabic
"ا": "a",
"أ": "a",
"إ": "i",
"آ": "aa",
"ؤ": "u",
"ئ": "e",
"ء": "a",
"ب": "b",
"ت": "t",
"ث": "th",
"ج": "j",
"ح": "h",
"خ": "kh",
"د": "d",
"ذ": "th",
"ر": "r",
"ز": "z",
"س": "s",
"ش": "sh",
"ص": "s",
"ض": "dh",
"ط": "t",
"ظ": "z",
"ع": "a",
"غ": "gh",
"ف": "f",
"ق": "q",
"ك": "k",
"ل": "l",
"م": "m",
"ن": "n",
"ه": "h",
"و": "w",
"ي": "y",
"ى": "a",
"ة": "h",
"ﻻ": "la",
"ﻷ": "laa",
"ﻹ": "lai",
"ﻵ": "laa",
// Persian additional characters than Arabic
"گ": "g",
"چ": "ch",
"پ": "p",
"ژ": "zh",
"ک": "k",
"ی": "y",
// Arabic diactrics
"َ": "a",
"ً": "an",
"ِ": "e",
"ٍ": "en",
"ُ": "u",
"ٌ": "on",
"ْ": "",
// Arabic numbers
"٠": "0",
"١": "1",
"٢": "2",
"٣": "3",
"٤": "4",
"٥": "5",
"٦": "6",
"٧": "7",
"٨": "8",
"٩": "9",
// Persian numbers
"۰": "0",
"۱": "1",
"۲": "2",
"۳": "3",
"۴": "4",
"۵": "5",
"۶": "6",
"۷": "7",
"۸": "8",
"۹": "9",
// Burmese consonants
"က": "k",
"ခ": "kh",
"ဂ": "g",
"ဃ": "ga",
"င": "ng",
"စ": "s",
"ဆ": "sa",
"ဇ": "z",
"စျ": "za",
"ည": "ny",
"ဋ": "t",
"ဌ": "ta",
"ဍ": "d",
"ဎ": "da",
"ဏ": "na",
"တ": "t",
"ထ": "ta",
"ဒ": "d",
"ဓ": "da",
"န": "n",
"ပ": "p",
"ဖ": "pa",
"ဗ": "b",
"ဘ": "ba",
"မ": "m",
"ယ": "y",
"ရ": "ya",
"လ": "l",
"ဝ": "w",
"သ": "th",
"ဟ": "h",
"ဠ": "la",
"အ": "a",
// consonant character combos
"ြ": "y",
"ျ": "ya",
"ွ": "w",
"ြွ": "yw",
"ျွ": "ywa",
"ှ": "h",
// independent vowels
"ဧ": "e",
"၏": "-e",
"ဣ": "i",
"ဤ": "-i",
"ဉ": "u",
"ဦ": "-u",
"ဩ": "aw",
"သြော": "aw",
"ဪ": "aw",
// numbers
"၀": "0",
"၁": "1",
"၂": "2",
"၃": "3",
"၄": "4",
"၅": "5",
"၆": "6",
"၇": "7",
"၈": "8",
"၉": "9",
// virama and tone marks which are silent in transliteration
"္": "",
"့": "",
"း": "",
// Czech
"č": "c",
"ď": "d",
"ě": "e",
"ň": "n",
"ř": "r",
"š": "s",
"ť": "t",
"ů": "u",
"ž": "z",
"Č": "C",
"Ď": "D",
"Ě": "E",
"Ň": "N",
"Ř": "R",
"Š": "S",
"Ť": "T",
"Ů": "U",
"Ž": "Z",
// Dhivehi
"ހ": "h",
"ށ": "sh",
"ނ": "n",
"ރ": "r",
"ބ": "b",
"ޅ": "lh",
"ކ": "k",
"އ": "a",
"ވ": "v",
"މ": "m",
"ފ": "f",
"ދ": "dh",
"ތ": "th",
"ލ": "l",
"ގ": "g",
"ޏ": "gn",
"ސ": "s",
"ޑ": "d",
"ޒ": "z",
"ޓ": "t",
"ޔ": "y",
"ޕ": "p",
"ޖ": "j",
"ޗ": "ch",
"ޘ": "tt",
"ޙ": "hh",
"ޚ": "kh",
"ޛ": "th",
"ޜ": "z",
"ޝ": "sh",
"ޞ": "s",
"ޟ": "d",
"ޠ": "t",
"ޡ": "z",
"ޢ": "a",
"ޣ": "gh",
"ޤ": "q",
"ޥ": "w",
"ަ": "a",
"ާ": "aa",
"ި": "i",
"ީ": "ee",
"ު": "u",
"ޫ": "oo",
"ެ": "e",
"ޭ": "ey",
"ޮ": "o",
"ޯ": "oa",
"ް": "",
// Georgian https://en.wikipedia.org/wiki/Romanization_of_Georgian
// National system (2002)
"ა": "a",
"ბ": "b",
"გ": "g",
"დ": "d",
"ე": "e",
"ვ": "v",
"ზ": "z",
"თ": "t",
"ი": "i",
"კ": "k",
"ლ": "l",
"მ": "m",
"ნ": "n",
"ო": "o",
"პ": "p",
"ჟ": "zh",
"რ": "r",
"ს": "s",
"ტ": "t",
"უ": "u",
"ფ": "p",
"ქ": "k",
"ღ": "gh",
"ყ": "q",
"შ": "sh",
"ჩ": "ch",
"ც": "ts",
"ძ": "dz",
"წ": "ts",
"ჭ": "ch",
"ხ": "kh",
"ჯ": "j",
"ჰ": "h",
// Greek
"α": "a",
"β": "v",
"γ": "g",
"δ": "d",
"ε": "e",
"ζ": "z",
"η": "i",
"θ": "th",
"ι": "i",
"κ": "k",
"λ": "l",
"μ": "m",
"ν": "n",
"ξ": "ks",
"ο": "o",
"π": "p",
"ρ": "r",
"σ": "s",
"τ": "t",
"υ": "y",
"φ": "f",
"χ": "x",
"ψ": "ps",
"ω": "o",
"ά": "a",
"έ": "e",
"ί": "i",
"ό": "o",
"ύ": "y",
"ή": "i",
"ώ": "o",
"ς": "s",
"ϊ": "i",
"ΰ": "y",
"ϋ": "y",
"ΐ": "i",
"Α": "A",
"Β": "B",
"Γ": "G",
"Δ": "D",
"Ε": "E",
"Ζ": "Z",
"Η": "I",
"Θ": "TH",
"Ι": "I",
"Κ": "K",
"Λ": "L",
"Μ": "M",
"Ν": "N",
"Ξ": "KS",
"Ο": "O",
"Π": "P",
"Ρ": "R",
"Σ": "S",
"Τ": "T",
"Υ": "Y",
"Φ": "F",
"Χ": "X",
"Ψ": "PS",
"Ω": "O",
"Ά": "A",
"Έ": "E",
"Ί": "I",
"Ό": "O",
"Ύ": "Y",
"Ή": "I",
"Ώ": "O",
"Ϊ": "I",
"Ϋ": "Y",
// Latvian
"ā": "a",
// 'č': 'c', // duplicate
"ē": "e",
"ģ": "g",
"ī": "i",
"ķ": "k",
"ļ": "l",
"ņ": "n",
// 'š': 's', // duplicate
"ū": "u",
// 'ž': 'z', // duplicate
"Ā": "A",
// 'Č': 'C', // duplicate
"Ē": "E",
"Ģ": "G",
"Ī": "I",
"Ķ": "k",
"Ļ": "L",
"Ņ": "N",
// 'Š': 'S', // duplicate
"Ū": "U",
// 'Ž': 'Z', // duplicate
// Macedonian
"Ќ": "Kj",
"ќ": "kj",
"Љ": "Lj",
"љ": "lj",
"Њ": "Nj",
"њ": "nj",
"Тс": "Ts",
"тс": "ts",
// Polish
"ą": "a",
"ć": "c",
"ę": "e",
"ł": "l",
"ń": "n",
// 'ó': 'o', // duplicate
"ś": "s",
"ź": "z",
"ż": "z",
"Ą": "A",
"Ć": "C",
"Ę": "E",
"Ł": "L",
"Ń": "N",
"Ś": "S",
"Ź": "Z",
"Ż": "Z",
// Ukranian
"Є": "Ye",
"І": "I",
"Ї": "Yi",
"Ґ": "G",
"є": "ye",
"і": "i",
"ї": "yi",
"ґ": "g",
// Romanian
"ă": "a",
"Ă": "A",
"ș": "s",
"Ș": "S",
// 'ş': 's', // duplicate
// 'Ş': 'S', // duplicate
"ț": "t",
"Ț": "T",
"ţ": "t",
"Ţ": "T",
// Russian https://en.wikipedia.org/wiki/Romanization_of_Russian
// ICAO
"а": "a",
"б": "b",
"в": "v",
"г": "g",
"д": "d",
"е": "e",
"ё": "yo",
"ж": "zh",
"з": "z",
"и": "i",
"й": "i",
"к": "k",
"л": "l",
"м": "m",
"н": "n",
"о": "o",
"п": "p",
"р": "r",
"с": "s",
"т": "t",
"у": "u",
"ф": "f",
"х": "kh",
"ц": "c",
"ч": "ch",
"ш": "sh",
"щ": "sh",
"ъ": "",
"ы": "y",
"ь": "",
"э": "e",
"ю": "yu",
"я": "ya",
"А": "A",
"Б": "B",
"В": "V",
"Г": "G",
"Д": "D",
"Е": "E",
"Ё": "Yo",
"Ж": "Zh",
"З": "Z",
"И": "I",
"Й": "I",
"К": "K",
"Л": "L",
"М": "M",
"Н": "N",
"О": "O",
"П": "P",
"Р": "R",
"С": "S",
"Т": "T",
"У": "U",
"Ф": "F",
"Х": "Kh",
"Ц": "C",
"Ч": "Ch",
"Ш": "Sh",
"Щ": "Sh",
"Ъ": "",
"Ы": "Y",
"Ь": "",
"Э": "E",
"Ю": "Yu",
"Я": "Ya",
// Serbian
"ђ": "dj",
"ј": "j",
// 'љ': 'lj', // duplicate
// 'њ': 'nj', // duplicate
"ћ": "c",
"џ": "dz",
"Ђ": "Dj",
"Ј": "j",
// 'Љ': 'Lj', // duplicate
// 'Њ': 'Nj', // duplicate
"Ћ": "C",
"Џ": "Dz",
// Slovak
"ľ": "l",
"ĺ": "l",
"ŕ": "r",
"Ľ": "L",
"Ĺ": "L",
"Ŕ": "R",
// Turkish
"ş": "s",
"Ş": "S",
"ı": "i",
"İ": "I",
// 'ç': 'c', // duplicate
// 'Ç': 'C', // duplicate
// 'ü': 'u', // duplicate, see langCharMap
// 'Ü': 'U', // duplicate, see langCharMap
// 'ö': 'o', // duplicate, see langCharMap
// 'Ö': 'O', // duplicate, see langCharMap
"ğ": "g",
"Ğ": "G",
// Vietnamese
"ả": "a",
"Ả": "A",
"ẳ": "a",
"Ẳ": "A",
"ẩ": "a",
"Ẩ": "A",
"đ": "d",
"Đ": "D",
"ẹ": "e",
"Ẹ": "E",
"ẽ": "e",
"Ẽ": "E",
"ẻ": "e",
"Ẻ": "E",
"ế": "e",
"Ế": "E",
"ề": "e",
"Ề": "E",
"ệ": "e",
"Ệ": "E",
"ễ": "e",
"Ễ": "E",
"ể": "e",
"Ể": "E",
"ỏ": "o",
"ọ": "o",
"Ọ": "o",
"ố": "o",
"Ố": "O",
"ồ": "o",
"Ồ": "O",
"ổ": "o",
"Ổ": "O",
"ộ": "o",
"Ộ": "O",
"ỗ": "o",
"Ỗ": "O",
"ơ": "o",
"Ơ": "O",
"ớ": "o",
"Ớ": "O",
"ờ": "o",
"Ờ": "O",
"ợ": "o",
"Ợ": "O",
"ỡ": "o",
"Ỡ": "O",
"Ở": "o",
"ở": "o",
"ị": "i",
"Ị": "I",
"ĩ": "i",
"Ĩ": "I",
"ỉ": "i",
"Ỉ": "i",
"ủ": "u",
"Ủ": "U",
"ụ": "u",
"Ụ": "U",
"ũ": "u",
"Ũ": "U",
"ư": "u",
"Ư": "U",
"ứ": "u",
"Ứ": "U",
"ừ": "u",
"Ừ": "U",
"ự": "u",
"Ự": "U",
"ữ": "u",
"Ữ": "U",
"ử": "u",
"Ử": "ư",
"ỷ": "y",
"Ỷ": "y",
"ỳ": "y",
"Ỳ": "Y",
"ỵ": "y",
"Ỵ": "Y",
"ỹ": "y",
"Ỹ": "Y",
"ạ": "a",
"Ạ": "A",
"ấ": "a",
"Ấ": "A",
"ầ": "a",
"Ầ": "A",
"ậ": "a",
"Ậ": "A",
"ẫ": "a",
"Ẫ": "A",
// 'ă': 'a', // duplicate
// 'Ă': 'A', // duplicate
"ắ": "a",
"Ắ": "A",
"ằ": "a",
"Ằ": "A",
"ặ": "a",
"Ặ": "A",
"ẵ": "a",
"Ẵ": "A",
"⓪": "0",
"①": "1",
"②": "2",
"③": "3",
"④": "4",
"⑤": "5",
"⑥": "6",
"⑦": "7",
"⑧": "8",
"⑨": "9",
"⑩": "10",
"⑪": "11",
"⑫": "12",
"⑬": "13",
"⑭": "14",
"⑮": "15",
"⑯": "16",
"⑰": "17",
"⑱": "18",
"⑲": "18",
"⑳": "18",
"⓵": "1",
"⓶": "2",
"⓷": "3",
"⓸": "4",
"⓹": "5",
"⓺": "6",
"⓻": "7",
"⓼": "8",
"⓽": "9",
"⓾": "10",
"⓿": "0",
"⓫": "11",
"⓬": "12",
"⓭": "13",
"⓮": "14",
"⓯": "15",
"⓰": "16",
"⓱": "17",
"⓲": "18",
"⓳": "19",
"⓴": "20",
"Ⓐ": "A",
"Ⓑ": "B",
"Ⓒ": "C",
"Ⓓ": "D",
"Ⓔ": "E",
"Ⓕ": "F",
"Ⓖ": "G",
"Ⓗ": "H",
"Ⓘ": "I",
"Ⓙ": "J",
"Ⓚ": "K",
"Ⓛ": "L",
"Ⓜ": "M",
"Ⓝ": "N",
"Ⓞ": "O",
"Ⓟ": "P",
"Ⓠ": "Q",
"Ⓡ": "R",
"Ⓢ": "S",
"Ⓣ": "T",
"Ⓤ": "U",
"Ⓥ": "V",
"Ⓦ": "W",
"Ⓧ": "X",
"Ⓨ": "Y",
"Ⓩ": "Z",
"ⓐ": "a",
"ⓑ": "b",
"ⓒ": "c",
"ⓓ": "d",
"ⓔ": "e",
"ⓕ": "f",
"ⓖ": "g",
"ⓗ": "h",
"ⓘ": "i",
"ⓙ": "j",
"ⓚ": "k",
"ⓛ": "l",
"ⓜ": "m",
"ⓝ": "n",
"ⓞ": "o",
"ⓟ": "p",
"ⓠ": "q",
"ⓡ": "r",
"ⓢ": "s",
"ⓣ": "t",
"ⓤ": "u",
"ⓦ": "v",
"ⓥ": "w",
"ⓧ": "x",
"ⓨ": "y",
"ⓩ": "z",
// symbols
"“": '"',
"”": '"',
"‘": "'",
"’": "'",
"∂": "d",
"ƒ": "f",
"™": "(TM)",
"©": "(C)",
"œ": "oe",
"Œ": "OE",
"®": "(R)",
"†": "+",
"℠": "(SM)",
"…": "...",
"˚": "o",
"º": "o",
"ª": "a",
"•": "*",
"၊": ",",
"။": ".",
// currency
"$": "USD",
"€": "EUR",
"₢": "BRN",
"₣": "FRF",
"£": "GBP",
"₤": "ITL",
"₦": "NGN",
"₧": "ESP",
"₩": "KRW",
"₪": "ILS",
"₫": "VND",
"₭": "LAK",
"₮": "MNT",
"₯": "GRD",
"₱": "ARS",
"₲": "PYG",
"₳": "ARA",
"₴": "UAH",
"₵": "GHS",
"¢": "cent",
"¥": "CNY",
"元": "CNY",
"円": "YEN",
"﷼": "IRR",
"₠": "EWE",
"฿": "THB",
"₨": "INR",
"₹": "INR",
"₰": "PF",
"₺": "TRY",
"؋": "AFN",
"₼": "AZN",
"лв": "BGN",
"៛": "KHR",
"₡": "CRC",
"₸": "KZT",
"ден": "MKD",
"zł": "PLN",
"₽": "RUB",
"₾": "GEL"
};
var lookAheadCharArray = [
// burmese
"်",
// Dhivehi
"ް"
];
var diatricMap = {
// Burmese
// dependent vowels
"ာ": "a",
"ါ": "a",
"ေ": "e",
"ဲ": "e",
"ိ": "i",
"ီ": "i",
"ို": "o",
"ု": "u",
"ူ": "u",
"ေါင်": "aung",
"ော": "aw",
"ော်": "aw",
"ေါ": "aw",
"ေါ်": "aw",
"်": "်",
// this is special case but the character will be converted to latin in the code
"က်": "et",
"ိုက်": "aik",
"ောက်": "auk",
"င်": "in",
"ိုင်": "aing",
"ောင်": "aung",
"စ်": "it",
"ည်": "i",
"တ်": "at",
"ိတ်": "eik",
"ုတ်": "ok",
"ွတ်": "ut",
"ေတ်": "it",
"ဒ်": "d",
"ိုဒ်": "ok",
"ုဒ်": "ait",
"န်": "an",
"ာန်": "an",
"ိန်": "ein",
"ုန်": "on",
"ွန်": "un",
"ပ်": "at",
"ိပ်": "eik",
"ုပ်": "ok",
"ွပ်": "ut",
"န်ုပ်": "nub",
"မ်": "an",
"ိမ်": "ein",
"ုမ်": "on",
"ွမ်": "un",
"ယ်": "e",
"ိုလ်": "ol",
"ဉ်": "in",
"ံ": "an",
"ိံ": "ein",
"ုံ": "on",
// Dhivehi
"ައް": "ah",
"ަށް": "ah"
};
var langCharMap = {
"en": {},
// default language
"az": {
// Azerbaijani
"ç": "c",
"ə": "e",
"ğ": "g",
"ı": "i",
"ö": "o",
"ş": "s",
"ü": "u",
"Ç": "C",
"Ə": "E",
"Ğ": "G",
"İ": "I",
"Ö": "O",
"Ş": "S",
"Ü": "U"
},
"cs": {
// Czech
"č": "c",
"ď": "d",
"ě": "e",
"ň": "n",
"ř": "r",
"š": "s",
"ť": "t",
"ů": "u",
"ž": "z",
"Č": "C",
"Ď": "D",
"Ě": "E",
"Ň": "N",
"Ř": "R",
"Š": "S",
"Ť": "T",
"Ů": "U",
"Ž": "Z"
},
"fi": {
// Finnish
// 'å': 'a', duplicate see charMap/latin
// 'Å': 'A', duplicate see charMap/latin
"ä": "a",
// ok
"Ä": "A",
// ok
"ö": "o",
// ok
"Ö": "O"
// ok
},
"hu": {
// Hungarian
"ä": "a",
// ok
"Ä": "A",
// ok
// 'á': 'a', duplicate see charMap/latin
// 'Á': 'A', duplicate see charMap/latin
"ö": "o",
// ok
"Ö": "O",
// ok
// 'ő': 'o', duplicate see charMap/latin
// 'Ő': 'O', duplicate see charMap/latin
"ü": "u",
"Ü": "U",
"ű": "u",
"Ű": "U"
},
"lt": {
// Lithuanian
"ą": "a",
"č": "c",
"ę": "e",
"ė": "e",
"į": "i",
"š": "s",
"ų": "u",
"ū": "u",
"ž": "z",
"Ą": "A",
"Č": "C",
"Ę": "E",
"Ė": "E",
"Į": "I",
"Š": "S",
"Ų": "U",
"Ū": "U"
},
"lv": {
// Latvian
"ā": "a",
"č": "c",
"ē": "e",
"ģ": "g",
"ī": "i",
"ķ": "k",
"ļ": "l",
"ņ": "n",
"š": "s",
"ū": "u",
"ž": "z",
"Ā": "A",
"Č": "C",
"Ē": "E",
"Ģ": "G",
"Ī": "i",
"Ķ": "k",
"Ļ": "L",
"Ņ": "N",
"Š": "S",
"Ū": "u",
"Ž": "Z"
},
"pl": {
// Polish
"ą": "a",
"ć": "c",
"ę": "e",
"ł": "l",
"ń": "n",
"ó": "o",
"ś": "s",
"ź": "z",
"ż": "z",
"Ą": "A",
"Ć": "C",
"Ę": "e",
"Ł": "L",
"Ń": "N",
"Ó": "O",
"Ś": "S",
"Ź": "Z",
"Ż": "Z"
},
"sv": {
// Swedish
// 'å': 'a', duplicate see charMap/latin
// 'Å': 'A', duplicate see charMap/latin
"ä": "a",
// ok
"Ä": "A",
// ok
"ö": "o",
// ok
"Ö": "O"
// ok
},
"sk": {
// Slovak
"ä": "a",
"Ä": "A"
},
"sr": {
// Serbian
"љ": "lj",
"њ": "nj",
"Љ": "Lj",
"Њ": "Nj",
"đ": "dj",
"Đ": "Dj"
},
"tr": {
// Turkish
"Ü": "U",
"Ö": "O",
"ü": "u",
"ö": "o"
}
};
var symbolMap = {
"ar": {
"∆": "delta",
"∞": "la-nihaya",
"♥": "hob",
"&": "wa",
"|": "aw",
"<": "aqal-men",
">": "akbar-men",
"∑": "majmou",
"¤": "omla"
},
"az": {},
"ca": {
"∆": "delta",
"∞": "infinit",
"♥": "amor",
"&": "i",
"|": "o",
"<": "menys que",
">": "mes que",
"∑": "suma dels",
"¤": "moneda"
},
"cs": {
"∆": "delta",
"∞": "nekonecno",
"♥": "laska",
"&": "a",
"|": "nebo",
"<": "mensi nez",
">": "vetsi nez",
"∑": "soucet",
"¤": "mena"
},
"de": {
"∆": "delta",
"∞": "unendlich",
"♥": "Liebe",
"&": "und",
"|": "oder",
"<": "kleiner als",
">": "groesser als",
"∑": "Summe von",
"¤": "Waehrung"
},
"dv": {
"∆": "delta",
"∞": "kolunulaa",
"♥": "loabi",
"&": "aai",
"|": "noonee",
"<": "ah vure kuda",
">": "ah vure bodu",
"∑": "jumula",
"¤": "faisaa"
},
"en": {
"∆": "delta",
"∞": "infinity",
"♥": "love",
"&": "and",
"|": "or",
"<": "less than",
">": "greater than",
"∑": "sum",
"¤": "currency"
},
"es": {
"∆": "delta",
"∞": "infinito",
"♥": "amor",
"&": "y",
"|": "u",
"<": "menos que",
">": "mas que",
"∑": "suma de los",
"¤": "moneda"
},
"fa": {
"∆": "delta",
"∞": "bi-nahayat",
"♥": "eshgh",
"&": "va",
"|": "ya",
"<": "kamtar-az",
">": "bishtar-az",
"∑": "majmooe",
"¤": "vahed"
},
"fi": {
"∆": "delta",
"∞": "aarettomyys",
"♥": "rakkaus",
"&": "ja",
"|": "tai",
"<": "pienempi kuin",
">": "suurempi kuin",
"∑": "summa",
"¤": "valuutta"
},
"fr": {
"∆": "delta",
"∞": "infiniment",
"♥": "Amour",
"&": "et",
"|": "ou",
"<": "moins que",
">": "superieure a",
"∑": "somme des",
"¤": "monnaie"
},
"ge": {
"∆": "delta",
"∞": "usasruloba",
"♥": "siqvaruli",
"&": "da",
"|": "an",
"<": "naklebi",
">": "meti",
"∑": "jami",
"¤": "valuta"
},
"gr": {},
"hu": {
"∆": "delta",
"∞": "vegtelen",
"♥": "szerelem",
"&": "es",
"|": "vagy",
"<": "kisebb mint",
">": "nagyobb mint",
"∑": "szumma",
"¤": "penznem"
},
"it": {
"∆": "delta",
"∞": "infinito",
"♥": "amore",
"&": "e",
"|": "o",
"<": "minore di",
">": "maggiore di",
"∑": "somma",
"¤": "moneta"
},
"lt": {
"∆": "delta",
"∞": "begalybe",
"♥": "meile",
"&": "ir",
"|": "ar",
"<": "maziau nei",
">": "daugiau nei",
"∑": "suma",
"¤": "valiuta"
},
"lv": {
"∆": "delta",
"∞": "bezgaliba",
"♥": "milestiba",
"&": "un",
"|": "vai",
"<": "mazak neka",
">": "lielaks neka",
"∑": "summa",
"¤": "valuta"
},
"my": {
"∆": "kwahkhyaet",
"∞": "asaonasme",
"♥": "akhyait",
"&": "nhin",
"|": "tho",
"<": "ngethaw",
">": "kyithaw",
"∑": "paungld",
"¤": "ngwekye"
},
"mk": {},
"nl": {
"∆": "delta",
"∞": "oneindig",
"♥": "liefde",
"&": "en",
"|": "of",
"<": "kleiner dan",
">": "groter dan",
"∑": "som",
"¤": "valuta"
},
"pl": {
"∆": "delta",
"∞": "nieskonczonosc",
"♥": "milosc",
"&": "i",
"|": "lub",
"<": "mniejsze niz",
">": "wieksze niz",
"∑": "suma",
"¤": "waluta"
},
"pt": {
"∆": "delta",
"∞": "infinito",
"♥": "amor",
"&": "e",
"|": "ou",
"<": "menor que",
">": "maior que",
"∑": "soma",
"¤": "moeda"
},
"ro": {
"∆": "delta",
"∞": "infinit",
"♥": "dragoste",
"&": "si",
"|": "sau",
"<": "mai mic ca",
">": "mai mare ca",
"∑": "suma",
"¤": "valuta"
},
"ru": {
"∆": "delta",
"∞": "beskonechno",
"♥": "lubov",
"&": "i",
"|": "ili",
"<": "menshe",
">": "bolshe",
"∑": "summa",
"¤": "valjuta"
},
"sk": {
"∆": "delta",
"∞": "nekonecno",
"♥": "laska",
"&": "a",
"|": "alebo",
"<": "menej ako",
">": "viac ako",
"∑": "sucet",
"¤": "mena"
},
"sr": {},
"tr": {
"∆": "delta",
"∞": "sonsuzluk",
"♥": "ask",
"&": "ve",
"|": "veya",
"<": "kucuktur",
">": "buyuktur",
"∑": "toplam",
"¤": "para birimi"
},
"uk": {
"∆": "delta",
"∞": "bezkinechnist",
"♥": "lubov",
"&": "i",
"|": "abo",
"<": "menshe",
">": "bilshe",
"∑": "suma",
"¤": "valjuta"
},
"vn": {
"∆": "delta",
"∞": "vo cuc",
"♥": "yeu",
"&": "va",
"|": "hoac",
"<": "nho hon",
">": "lon hon",
"∑": "tong",
"¤": "tien te"
}
};
var uricChars = [";", "?", ":", "@", "&", "=", "+", "$", ",", "/"].join("");
var uricNoSlashChars = [";", "?", ":", "@", "&", "=", "+", "$", ","].join("");
var markChars = [".", "!", "~", "*", "'", "(", ")"].join("");
var getSlug = function getSlug2(input, opts) {
var separator = "-";
var result = "";
var diatricString = "";
var convertSymbols = true;
var customReplacements = {};
var maintainCase;
var titleCase;
var truncate;
var uricFlag;
var uricNoSlashFlag;
var markFlag;
var symbol;
var langChar;
var lucky;
var i;
var ch;
var l;
var lastCharWasSymbol;
var lastCharWasDiatric;
var allowedChars = "";
if (typeof input !== "string") {
return "";
}
if (typeof opts === "string") {
separator = opts;
}
symbol = symbolMap.en;
langChar = langCharMap.en;
if (typeof opts === "object") {
maintainCase = opts.maintainCase || false;
customReplacements = opts.custom && typeof opts.custom === "object" ? opts.custom : customReplacements;
truncate = +opts.truncate > 1 && opts.truncate || false;
uricFlag = opts.uric || false;
uricNoSlashFlag = opts.uricNoSlash || false;
markFlag = opts.mark || false;
convertSymbols = opts.symbols === false || opts.lang === false ? false : true;
separator = opts.separator || separator;
if (uricFlag) {
allowedChars += uricChars;
}
if (uricNoSlashFlag) {
allowedChars += uricNoSlashChars;
}
if (markFlag) {
allowedChars += markChars;
}
symbol = opts.lang && symbolMap[opts.lang] && convertSymbols ? symbolMap[opts.lang] : convertSymbols ? symbolMap.en : {};
langChar = opts.lang && langCharMap[opts.lang] ? langCharMap[opts.lang] : opts.lang === false || opts.lang === true ? {} : langCharMap.en;
if (opts.titleCase && typeof opts.titleCase.length === "number" && Array.prototype.toString.call(opts.titleCase)) {
opts.titleCase.forEach(function(v) {
customReplacements[v + ""] = v + "";
});
titleCase = true;
} else {
titleCase = !!opts.titleCase;
}
if (opts.custom && typeof opts.custom.length === "number" && Array.prototype.toString.call(opts.custom)) {
opts.custom.forEach(function(v) {
customReplacements[v + ""] = v + "";
});
}
Object.keys(customReplacements).forEach(function(v) {
var r;
if (v.length > 1) {
r = new RegExp("\\b" + escapeChars(v) + "\\b", "gi");
} else {
r = new RegExp(escapeChars(v), "gi");
}
input = input.replace(r, customReplacements[v]);
});
for (ch in customReplacements) {
allowedChars += ch;
}
}
allowedChars += separator;
allowedChars = escapeChars(allowedChars);
input = input.replace(/(^\s+|\s+$)/g, "");
lastCharWasSymbol = false;
lastCharWasDiatric = false;
for (i = 0, l = input.length; i < l; i++) {
ch = input[i];
if (isReplacedCustomChar(ch, customReplacements)) {
lastCharWasSymbol = false;
} else if (langChar[ch]) {
ch = lastCharWasSymbol && langChar[ch].match(/[A-Za-z0-9]/) ? " " + langChar[ch] : langChar[ch];
lastCharWasSymbol = false;
} else if (ch in charMap) {
if (i + 1 < l && lookAheadCharArray.indexOf(input[i + 1]) >= 0) {
diatricString += ch;
ch = "";
} else if (lastCharWasDiatric === true) {
ch = diatricMap[diatricString] + charMap[ch];
diatricString = "";
} else {
ch = lastCharWasSymbol && charMap[ch].match(/[A-Za-z0-9]/) ? " " + charMap[ch] : charMap[ch];
}
lastCharWasSymbol = false;
lastCharWasDiatric = false;
} else if (ch in diatricMap) {
diatricString += ch;
ch = "";
if (i === l - 1) {
ch = diatricMap[diatricString];
}
lastCharWasDiatric = true;
} else if (
// process symbol chars
symbol[ch] && !(uricFlag && uricChars.indexOf(ch) !== -1) && !(uricNoSlashFlag && uricNoSlashChars.indexOf(ch) !== -1)
) {
ch = lastCharWasSymbol || result.substr(-1).match(/[A-Za-z0-9]/) ? separator + symbol[ch] : symbol[ch];
ch += input[i + 1] !== void 0 && input[i + 1].match(/[A-Za-z0-9]/) ? separator : "";
lastCharWasSymbol = true;
} else {
if (lastCharWasDiatric === true) {
ch = diatricMap[diatricString] + ch;
diatricString = "";
lastCharWasDiatric = false;
} else if (lastCharWasSymbol && (/[A-Za-z0-9]/.test(ch) || result.substr(-1).match(/A-Za-z0-9]/))) {
ch = " " + ch;
}
lastCharWasSymbol = false;
}
result += ch.replace(new RegExp("[^\\w\\s" + allowedChars + "_-]", "g"), separator);
}
if (titleCase) {
result = result.replace(/(\w)(\S*)/g, function(_, i2, r) {
var j = i2.toUpperCase() + (r !== null ? r : "");
return Object.keys(customReplacements).indexOf(j.toLowerCase()) < 0 ? j : j.toLowerCase();
});
}
result = result.replace(/\s+/g, separator).replace(new RegExp("\\" + separator + "+", "g"), separator).replace(new RegExp("(^\\" + separator + "+|\\" + separator + "+$)", "g"), "");
if (truncate && result.length > truncate) {
lucky = result.charAt(truncate) === separator;
result = result.slice(0, truncate);
if (!lucky) {
result = result.slice(0, result.lastIndexOf(separator));
}
}
if (!maintainCase && !titleCase) {
result = result.toLowerCase();
}
return result;
};
var createSlug = function createSlug2(opts) {
return function getSlugWithConfig(input) {
return getSlug(input, opts);
};
};
var escapeChars = function escapeChars2(input) {
return input.replace(/[-\\^$*+?.()|[\]{}\/]/g, "\\$&");
};
var isReplacedCustomChar = function(ch, customReplacements) {
for (var c in customReplacements) {
if (customReplacements[c] === ch) {
return true;
}
}
};
if (typeof module !== "undefined" && module.exports) {
module.exports = getSlug;
module.exports.createSlug = createSlug;
} else if (typeof define !== "undefined" && define.amd) {
define([], function() {
return getSlug;
});
} else {
try {
if (root.getSlug || root.createSlug) {
throw "speakingurl: globals exists /(getSlug|createSlug)/";
} else {
root.getSlug = getSlug;
root.createSlug = createSlug;
}
} catch (e) {
}
}
})(exports);
}
});
var require_speakingurl2 = __commonJS2({
"../../node_modules/.pnpm/[email protected]/node_modules/speakingurl/index.js"(exports, module) {
"use strict";
init_esm_shims2();
module.exports = require_speakingurl();
}
});
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
function getComponentTypeName(options) {
var _a25;
const name = options.name || options._componentTag || options.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ || options.__name;
if (name === "index" && ((_a25 = options.__file) == null ? void 0 : _a25.endsWith("index.vue"))) {
return "";
}
return name;
}
function getComponentFileName(options) {
const file = options.__file;
if (file)
return classify(basename(file, ".vue"));
}
function saveComponentGussedName(instance, name) {
instance.type.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ = name;
return name;
}
function getAppRecord(instance) {
if (instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__)
return instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
else if (instance.root)
return instance.appContext.app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
}
function isFragment(instance) {
var _a25, _b25;
const subTreeType = (_a25 = instance.subTree) == null ? void 0 : _a25.type;
const appRecord = getAppRecord(instance);
if (appRecord) {
return ((_b25 = appRecord == null ? void 0 : appRecord.types) == null ? void 0 : _b25.Fragment) === subTreeType;
}
return false;
}
function getInstanceName(instance) {
var _a25, _b25, _c;
const name = getComponentTypeName((instance == null ? void 0 : instance.type) || {});
if (name)
return name;
if ((instance == null ? void 0 : instance.root) === instance)
return "Root";
for (const key in (_b25 = (_a25 = instance.parent) == null ? void 0 : _a25.type) == null ? void 0 : _b25.components) {
if (instance.parent.type.components[key] === (instance == null ? void 0 : instance.type))
return saveComponentGussedName(instance, key);
}
for (const key in (_c = instance.appContext) == null ? void 0 : _c.components) {
if (instance.appContext.components[key] === (instance == null ? void 0 : instance.type))
return saveComponentGussedName(instance, key);
}
const fileName = getComponentFileName((instance == null ? void 0 : instance.type) || {});
if (fileName)
return fileName;
return "Anonymous Component";
}
function getUniqueComponentId(instance) {
var _a25, _b25, _c;
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;
const instanceId = instance === (instance == null ? void 0 : instance.root) ? "root" : instance.uid;
return `${appId}:${instanceId}`;
}
function getComponentInstance(appRecord, instanceId) {
instanceId = instanceId || `${appRecord.id}:root`;
const instance = appRecord.instanceMap.get(instanceId);
return instance || appRecord.instanceMap.get(":root");
}
function createRect() {
const rect = {
top: 0,
bottom: 0,
left: 0,
right: 0,
get width() {
return rect.right - rect.left;
},
get height() {
return rect.bottom - rect.top;
}
};
return rect;
}
var range;
function getTextRect(node) {
if (!range)
range = document.createRange();
range.selectNode(node);
return range.getBoundingClientRect();
}
function getFragmentRect(vnode) {
const rect = createRect();
if (!vnode.children)
return rect;
for (let i = 0, l = vnode.children.length; i < l; i++) {
const childVnode = vnode.children[i];
let childRect;
if (childVnode.component) {
childRect = getComponentBoundingRect(childVnode.component);
} else if (childVnode.el) {
const el = childVnode.el;
if (el.nodeType === 1 || el.getBoundingClientRect)
childRect = el.getBoundingClientRect();
else if (el.nodeType === 3 && el.data.trim())
childRect = getTextRect(el);
}
if (childRect)
mergeRects(rect, childRect);
}
return rect;
}
function mergeRects(a, b) {
if (!a.top || b.top < a.top)
a.top = b.top;
if (!a.bottom || b.bottom > a.bottom)
a.bottom = b.bottom;
if (!a.left || b.left < a.left)
a.left = b.left;
if (!a.right || b.right > a.right)
a.right = b.right;
return a;
}
var DEFAULT_RECT = {
top: 0,
left: 0,
right: 0,
bottom: 0,
width: 0,
height: 0
};
function getComponentBoundingRect(instance) {
const el = instance.subTree.el;
if (typeof window === "undefined") {
return DEFAULT_RECT;
}
if (isFragment(instance))
return getFragmentRect(instance.subTree);
else if ((el == null ? void 0 : el.nodeType) === 1)
return el == null ? void 0 : el.getBoundingClientRect();
else if (instance.subTree.component)
return getComponentBoundingRect(instance.subTree.component);
else
return DEFAULT_RECT;
}
init_esm_shims2();
function getRootElementsFromComponentInstance(instance) {
if (isFragment(instance))
return getFragmentRootElements(instance.subTree);
if (!instance.subTree)
return [];
return [instance.subTree.el];
}
function getFragmentRootElements(vnode) {
if (!vnode.children)
return [];
const list = [];
vnode.children.forEach((childVnode) => {
if (childVnode.component)
list.push(...getRootElementsFromComponentInstance(childVnode.component));
else if (childVnode == null ? void 0 : childVnode.el)
list.push(childVnode.el);
});
return list;
}
var CONTAINER_ELEMENT_ID = "__vue-devtools-component-inspector__";
var CARD_ELEMENT_ID = "__vue-devtools-component-inspector__card__";
var COMPONENT_NAME_ELEMENT_ID = "__vue-devtools-component-inspector__name__";
var INDICATOR_ELEMENT_ID = "__vue-devtools-component-inspector__indicator__";
var containerStyles = {
display: "block",
zIndex: 2147483640,
position: "fixed",
backgroundColor: "#42b88325",
border: "1px solid #42b88350",
borderRadius: "5px",
transition: "all 0.1s ease-in",
pointerEvents: "none"
};
var cardStyles = {
fontFamily: "Arial, Helvetica, sans-serif",
padding: "5px 8px",
borderRadius: "4px",
textAlign: "left",
position: "absolute",
left: 0,
color: "#e9e9e9",
fontSize: "14px",
fontWeight: 600,
lineHeight: "24px",
backgroundColor: "#42b883",
boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)"
};
var indicatorStyles = {
display: "inline-block",
fontWeight: 400,
fontStyle: "normal",
fontSize: "12px",
opacity: 0.7
};
function getContainerElement() {
return document.getElementById(CONTAINER_ELEMENT_ID);
}
function getCardElement() {
return document.getElementById(CARD_ELEMENT_ID);
}
function getIndicatorElement() {
return document.getElementById(INDICATOR_ELEMENT_ID);
}
function getNameElement() {
return document.getElementById(COMPONENT_NAME_ELEMENT_ID);
}
function getStyles(bounds) {
return {
left: `${Math.round(bounds.left * 100) / 100}px`,
top: `${Math.round(bounds.top * 100) / 100}px`,
width: `${Math.round(bounds.width * 100) / 100}px`,
height: `${Math.round(bounds.height * 100) / 100}px`
};
}
function create(options) {
var _a25;
const containerEl = document.createElement("div");
containerEl.id = (_a25 = options.elementId) != null ? _a25 : CONTAINER_ELEMENT_ID;
Object.assign(containerEl.style, {
...containerStyles,
...getStyles(options.bounds),
...options.style
});
const cardEl = document.createElement("span");
cardEl.id = CARD_ELEMENT_ID;
Object.assign(cardEl.style, {
...cardStyles,
top: options.bounds.top < 35 ? 0 : "-35px"
});
const nameEl = document.createElement("span");
nameEl.id = COMPONENT_NAME_ELEMENT_ID;
nameEl.innerHTML = `<${options.name}> `;
const indicatorEl = document.createElement("i");
indicatorEl.id = INDICATOR_ELEMENT_ID;
indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
Object.assign(indicatorEl.style, indicatorStyles);
cardEl.appendChild(nameEl);
cardEl.appendChild(indicatorEl);
containerEl.appendChild(cardEl);
document.body.appendChild(containerEl);
return containerEl;
}
function update(options) {
const containerEl = getContainerElement();
const cardEl = getCardElement();
const nameEl = getNameElement();
const indicatorEl = getIndicatorElement();
if (containerEl) {
Object.assign(containerEl.style, {
...containerStyles,
...getStyles(options.bounds)
});
Object.assign(cardEl.style, {
top: options.bounds.top < 35 ? 0 : "-35px"
});
nameEl.innerHTML = `<${options.name}> `;
indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
}
}
function highlight(instance) {
const bounds = getComponentBoundingRect(instance);
if (!bounds.width && !bounds.height)
return;
const name = getInstanceName(instance);
const container = getContainerElement();
container ? update({ bounds, name }) : create({ bounds, name });
}
function unhighlight() {
const el = getContainerElement();
if (el)
el.style.display = "none";
}
var inspectInstance = null;
function inspectFn(e) {
const target22 = e.target;
if (target22) {
const instance = target22.__vueParentComponent;
if (instance) {
inspectInstance = instance;
const el = instance.vnode.el;
if (el) {
const bounds = getComponentBoundingRect(instance);
const name = getInstanceName(instance);
const container = getContainerElement();
container ? update({ bounds, name }) : create({ bounds, name });
}
}
}
}
function selectComponentFn(e, cb) {
e.preventDefault();
e.stopPropagation();
if (inspectInstance) {
const uniqueComponentId = getUniqueComponentId(inspectInstance);
cb(uniqueComponentId);
}
}
var inspectComponentHighLighterSelectFn = null;
function cancelInspectComponentHighLighter() {
unhighlight();
window.removeEventListener("mouseover", inspectFn);
window.removeEventListener("click", inspectComponentHighLighterSelectFn, true);
inspectComponentHighLighterSelectFn = null;
}
function inspectComponentHighLighter() {
window.addEventListener("mouseover", inspectFn);
return new Promise((resolve) => {
function onSelect(e) {
e.preventDefault();
e.stopPropagation();
selectComponentFn(e, (id) => {
window.removeEventListener("click", onSelect, true);
inspectComponentHighLighterSelectFn = null;
window.removeEventListener("mouseover", inspectFn);
const el = getContainerElement();
if (el)
el.style.display = "none";
resolve(JSON.stringify({ id }));
});
}
inspectComponentHighLighterSelectFn = onSelect;
window.addEventListener("click", onSelect, true);
});
}
function scrollToComponent(options) {
const instance = getComponentInstance(activeAppRecord.value, options.id);
if (instance) {
const [el] = getRootElementsFromComponentInstance(instance);
if (typeof el.scrollIntoView === "function") {
el.scrollIntoView({
behavior: "smooth"
});
} else {
const bounds = getComponentBoundingRect(instance);
const scrollTarget = document.createElement("div");
const styles = {
...getStyles(bounds),
position: "absolute"
};
Object.assign(scrollTarget.style, styles);
document.body.appendChild(scrollTarget);
scrollTarget.scrollIntoView({
behavior: "smooth"
});
setTimeout(() => {
document.body.removeChild(scrollTarget);
}, 2e3);
}
setTimeout(() => {
const bounds = getComponentBoundingRect(instance);
if (bounds.width || bounds.height) {
const name = getInstanceName(instance);
const el2 = getContainerElement();
el2 ? update({ ...options, name, bounds }) : create({ ...options, name, bounds });
setTimeout(() => {
if (el2)
el2.style.display = "none";
}, 1500);
}
}, 1200);
}
}
init_esm_shims2();
var _a2;
var _b;
(_b = (_a2 = target).__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__) != null ? _b : _a2.__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__ = true;
function waitForInspectorInit(cb) {
let total = 0;
const timer = setInterval(() => {
if (target.__VUE_INSPECTOR__) {
clearInterval(timer);
total += 30;
cb();
}
if (total >= /* 5s */
5e3)
clearInterval(timer);
}, 30);
}
function setupInspector() {
const inspector = target.__VUE_INSPECTOR__;
const _openInEditor = inspector.openInEditor;
inspector.openInEditor = async (...params) => {
inspector.disable();
_openInEditor(...params);
};
}
function getComponentInspector() {
return new Promise((resolve) => {
function setup() {
setupInspector();
resolve(target.__VUE_INSPECTOR__);
}
if (!target.__VUE_INSPECTOR__) {
waitForInspectorInit(() => {
setup();
});
} else {
setup();
}
});
}
init_esm_shims2();
init_esm_shims2();
function isReadonly(value) {
return !!(value && value[
"__v_isReadonly"
/* IS_READONLY */
]);
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value[
"__v_raw"
/* RAW */
]);
}
return !!(value && value[
"__v_isReactive"
/* IS_REACTIVE */
]);
}
function isRef(r) {
return !!(r && r.__v_isRef === true);
}
function toRaw(observed) {
const raw = observed && observed[
"__v_raw"
/* RAW */
];
return raw ? toRaw(raw) : observed;
}
var Fragment = Symbol.for("v-fgt");
var StateEditor = class {
constructor() {
this.refEditor = new RefStateEditor();
}
set(object, path, value, cb) {
const sections = Array.isArray(path) ? path : path.split(".");
const markRef = false;
while (sections.length > 1) {
const section = sections.shift();
if (object instanceof Map)
object = object.get(section);
else if (object instanceof Set)
object = Array.from(object.values())[section];
else object = object[section];
if (this.refEditor.isRef(object))
object = this.refEditor.get(object);
}
const field = sections[0];
const item = this.refEditor.get(object)[field];
if (cb) {
cb(object, field, value);
} else {
if (this.refEditor.isRef(item))
this.refEditor.set(item, value);
else if (markRef)
object[field] = value;
else
object[field] = value;
}
}
get(object, path) {
const sections = Array.isArray(path) ? path : path.split(".");
for (let i = 0; i < sections.length; i++) {
if (object instanceof Map)
object = object.get(sections[i]);
else
object = object[sections[i]];
if (this.refEditor.isRef(object))
object = this.refEditor.get(object);
if (!object)
return void 0;
}
return object;
}
has(object, path, parent = false) {
if (typeof object === "undefined")
return false;
const sections = Array.isArray(path) ? path.slice() : path.split(".");
const size = !parent ? 1 : 2;
while (object && sections.length > size) {
const section = sections.shift();
object = object[section];
if (this.refEditor.isRef(object))
object = this.refEditor.get(object);
}
return object != null && Object.prototype.hasOwnProperty.call(object, sections[0]);
}
createDefaultSetCallback(state) {
return (object, field, value) => {
if (state.remove || state.newKey) {
if (Array.isArray(object))
object.splice(field, 1);
else if (toRaw(object) instanceof Map)
object.delete(field);
else if (toRaw(object) instanceof Set)
object.delete(Array.from(object.values())[field]);
else Reflect.deleteProperty(object, field);
}
if (!state.remove) {
const target22 = object[state.newKey || field];
if (this.refEditor.isRef(target22))
this.refEditor.set(target22, value);
else if (toRaw(object) instanceof Map)
object.set(state.newKey || field, value);
else if (toRaw(object) instanceof Set)
object.add(value);
else
object[state.newKey || field] = value;
}
};
}
};
var RefStateEditor = class {
set(ref, value) {
if (isRef(ref)) {
ref.value = value;
} else {
if (ref instanceof Set && Array.isArray(value)) {
ref.clear();
value.forEach((v) => ref.add(v));
return;
}
const currentKeys = Object.keys(value);
if (ref instanceof Map) {
const previousKeysSet2 = new Set(ref.keys());
currentKeys.forEach((key) => {
ref.set(key, Reflect.get(value, key));
previousKeysSet2.delete(key);
});
previousKeysSet2.forEach((key) => ref.delete(key));
return;
}
const previousKeysSet = new Set(Object.keys(ref));
currentKeys.forEach((key) => {
Reflect.set(ref, key, Reflect.get(value, key));
previousKeysSet.delete(key);
});
previousKeysSet.forEach((key) => Reflect.deleteProperty(ref, key));
}
}
get(ref) {
return isRef(ref) ? ref.value : ref;
}
isRef(ref) {
return isRef(ref) || isReactive(ref);
}
};
var stateEditor = new StateEditor();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var TIMELINE_LAYERS_STATE_STORAGE_ID = "__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS_STATE__";
function getTimelineLayersStateFromStorage() {
if (!isBrowser || typeof localStorage === "undefined" || localStorage === null) {
return {
recordingState: false,
mouseEventEnabled: false,
keyboardEventEnabled: false,
componentEventEnabled: false,
performanceEventEnabled: false,
selected: ""
};
}
const state = localStorage.getItem(TIMELINE_LAYERS_STATE_STORAGE_ID);
return state ? JSON.parse(state) : {
recordingState: false,
mouseEventEnabled: false,
keyboardEventEnabled: false,
componentEventEnabled: false,
performanceEventEnabled: false,
selected: ""
};
}
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var _a22;
var _b2;
(_b2 = (_a22 = target).__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS) != null ? _b2 : _a22.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS = [];
var devtoolsTimelineLayers = new Proxy(target.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS, {
get(target22, prop, receiver) {
return Reflect.get(target22, prop, receiver);
}
});
function addTimelineLayer(options, descriptor) {
devtoolsState.timelineLayersState[descriptor.id] = false;
devtoolsTimelineLayers.push({
...options,
descriptorId: descriptor.id,
appRecord: getAppRecord(descriptor.app)
});
}
var _a3;
var _b3;
(_b3 = (_a3 = target).__VUE_DEVTOOLS_KIT_INSPECTOR__) != null ? _b3 : _a3.__VUE_DEVTOOLS_KIT_INSPECTOR__ = [];
var devtoolsInspector = new Proxy(target.__VUE_DEVTOOLS_KIT_INSPECTOR__, {
get(target22, prop, receiver) {
return Reflect.get(target22, prop, receiver);
}
});
var callInspectorUpdatedHook = debounce(() => {
devtoolsContext.hooks.callHook("sendInspectorToClient", getActiveInspectors());
});
function addInspector(inspector, descriptor) {
var _a25, _b25;
devtoolsInspector.push({
options: inspector,
descriptor,
treeFilterPlaceholder: (_a25 = inspector.treeFilterPlaceholder) != null ? _a25 : "Search tree...",
stateFilterPlaceholder: (_b25 = inspector.stateFilterPlaceholder) != null ? _b25 : "Search state...",
treeFilter: "",
selectedNodeId: "",
appRecord: getAppRecord(descriptor.app)
});
callInspectorUpdatedHook();
}
function getActiveInspectors() {
return devtoolsInspector.filter((inspector) => inspector.descriptor.app === activeAppRecord.value.app).filter((inspector) => inspector.descriptor.id !== "components").map((inspector) => {
var _a25;
const descriptor = inspector.descriptor;
const options = inspector.options;
return {
id: options.id,
label: options.label,
logo: descriptor.logo,
icon: `custom-ic-baseline-${(_a25 = options == null ? void 0 : options.icon) == null ? void 0 : _a25.replace(/_/g, "-")}`,
packageName: descriptor.packageName,
homepage: descriptor.homepage,
pluginId: descriptor.id
};
});
}
function getInspector(id, app) {
return devtoolsInspector.find((inspector) => inspector.options.id === id && (app ? inspector.descriptor.app === app : true));
}
var DevToolsV6PluginAPIHookKeys = ((DevToolsV6PluginAPIHookKeys2) => {
DevToolsV6PluginAPIHookKeys2["VISIT_COMPONENT_TREE"] = "visitComponentTree";
DevToolsV6PluginAPIHookKeys2["INSPECT_COMPONENT"] = "inspectComponent";
DevToolsV6PluginAPIHookKeys2["EDIT_COMPONENT_STATE"] = "editComponentState";
DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_TREE"] = "getInspectorTree";
DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_STATE"] = "getInspectorState";
DevToolsV6PluginAPIHookKeys2["EDIT_INSPECTOR_STATE"] = "editInspectorState";
DevToolsV6PluginAPIHookKeys2["INSPECT_TIMELINE_EVENT"] = "inspectTimelineEvent";
DevToolsV6PluginAPIHookKeys2["TIMELINE_CLEARED"] = "timelineCleared";
DevToolsV6PluginAPIHookKeys2["SET_PLUGIN_SETTINGS"] = "setPluginSettings";
return DevToolsV6PluginAPIHookKeys2;
})(DevToolsV6PluginAPIHookKeys || {});
var DevToolsContextHookKeys = ((DevToolsContextHookKeys2) => {
DevToolsContextHookKeys2["ADD_INSPECTOR"] = "addInspector";
DevToolsContextHookKeys2["SEND_INSPECTOR_TREE"] = "sendInspectorTree";
DevToolsContextHookKeys2["SEND_INSPECTOR_STATE"] = "sendInspectorState";
DevToolsContextHookKeys2["CUSTOM_INSPECTOR_SELECT_NODE"] = "customInspectorSelectNode";
DevToolsContextHookKeys2["TIMELINE_LAYER_ADDED"] = "timelineLayerAdded";
DevToolsContextHookKeys2["TIMELINE_EVENT_ADDED"] = "timelineEventAdded";
DevToolsContextHookKeys2["GET_COMPONENT_INSTANCES"] = "getComponentInstances";
DevToolsContextHookKeys2["GET_COMPONENT_BOUNDS"] = "getComponentBounds";
DevToolsContextHookKeys2["GET_COMPONENT_NAME"] = "getComponentName";
DevToolsContextHookKeys2["COMPONENT_HIGHLIGHT"] = "componentHighlight";
DevToolsContextHookKeys2["COMPONENT_UNHIGHLIGHT"] = "componentUnhighlight";
return DevToolsContextHookKeys2;
})(DevToolsContextHookKeys || {});
var DevToolsMessagingHookKeys = ((DevToolsMessagingHookKeys2) => {
DevToolsMessagingHookKeys2["SEND_INSPECTOR_TREE_TO_CLIENT"] = "sendInspectorTreeToClient";
DevToolsMessagingHookKeys2["SEND_INSPECTOR_STATE_TO_CLIENT"] = "sendInspectorStateToClient";
DevToolsMessagingHookKeys2["SEND_TIMELINE_EVENT_TO_CLIENT"] = "sendTimelineEventToClient";
DevToolsMessagingHookKeys2["SEND_INSPECTOR_TO_CLIENT"] = "sendInspectorToClient";
DevToolsMessagingHookKeys2["SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT"] = "sendActiveAppUpdatedToClient";
DevToolsMessagingHookKeys2["DEVTOOLS_STATE_UPDATED"] = "devtoolsStateUpdated";
DevToolsMessagingHookKeys2["DEVTOOLS_CONNECTED_UPDATED"] = "devtoolsConnectedUpdated";
DevToolsMessagingHookKeys2["ROUTER_INFO_UPDATED"] = "routerInfoUpdated";
return DevToolsMessagingHookKeys2;
})(DevToolsMessagingHookKeys || {});
function createDevToolsCtxHooks() {
const hooks2 = createHooks();
hooks2.hook("addInspector", ({ inspector, plugin }) => {
addInspector(inspector, plugin.descriptor);
});
const debounceSendInspectorTree = debounce(async ({ inspectorId, plugin }) => {
var _a25;
if (!inspectorId || !((_a25 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a25.app) || devtoolsState.highPerfModeEnabled)
return;
const inspector = getInspector(inspectorId, plugin.descriptor.app);
const _payload = {
app: plugin.descriptor.app,
inspectorId,
filter: (inspector == null ? void 0 : inspector.treeFilter) || "",
rootNodes: []
};
await new Promise((resolve) => {
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb(_payload)));
resolve();
},
"getInspectorTree"
/* GET_INSPECTOR_TREE */
);
});
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb({
inspectorId,
rootNodes: _payload.rootNodes
})));
},
"sendInspectorTreeToClient"
/* SEND_INSPECTOR_TREE_TO_CLIENT */
);
}, 120);
hooks2.hook("sendInspectorTree", debounceSendInspectorTree);
const debounceSendInspectorState = debounce(async ({ inspectorId, plugin }) => {
var _a25;
if (!inspectorId || !((_a25 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a25.app) || devtoolsState.highPerfModeEnabled)
return;
const inspector = getInspector(inspectorId, plugin.descriptor.app);
const _payload = {
app: plugin.descriptor.app,
inspectorId,
nodeId: (inspector == null ? void 0 : inspector.selectedNodeId) || "",
state: null
};
const ctx = {
currentTab: `custom-inspector:${inspectorId}`
};
if (_payload.nodeId) {
await new Promise((resolve) => {
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
resolve();
},
"getInspectorState"
/* GET_INSPECTOR_STATE */
);
});
}
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb({
inspectorId,
nodeId: _payload.nodeId,
state: _payload.state
})));
},
"sendInspectorStateToClient"
/* SEND_INSPECTOR_STATE_TO_CLIENT */
);
}, 120);
hooks2.hook("sendInspectorState", debounceSendInspectorState);
hooks2.hook("customInspectorSelectNode", ({ inspectorId, nodeId, plugin }) => {
const inspector = getInspector(inspectorId, plugin.descriptor.app);
if (!inspector)
return;
inspector.selectedNodeId = nodeId;
});
hooks2.hook("timelineLayerAdded", ({ options, plugin }) => {
addTimelineLayer(options, plugin.descriptor);
});
hooks2.hook("timelineEventAdded", ({ options, plugin }) => {
var _a25;
const internalLayerIds = ["performance", "component-event", "keyboard", "mouse"];
if (devtoolsState.highPerfModeEnabled || !((_a25 = devtoolsState.timelineLayersState) == null ? void 0 : _a25[plugin.descriptor.id]) && !internalLayerIds.includes(options.layerId))
return;
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb(options)));
},
"sendTimelineEventToClient"
/* SEND_TIMELINE_EVENT_TO_CLIENT */
);
});
hooks2.hook("getComponentInstances", async ({ app }) => {
const appRecord = app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
if (!appRecord)
return null;
const appId = appRecord.id.toString();
const instances = [...appRecord.instanceMap].filter(([key]) => key.split(":")[0] === appId).map(([, instance]) => instance);
return instances;
});
hooks2.hook("getComponentBounds", async ({ instance }) => {
const bounds = getComponentBoundingRect(instance);
return bounds;
});
hooks2.hook("getComponentName", ({ instance }) => {
const name = getInstanceName(instance);
return name;
});
hooks2.hook("componentHighlight", ({ uid }) => {
const instance = activeAppRecord.value.instanceMap.get(uid);
if (instance) {
highlight(instance);
}
});
hooks2.hook("componentUnhighlight", () => {
unhighlight();
});
return hooks2;
}
var _a4;
var _b4;
(_b4 = (_a4 = target).__VUE_DEVTOOLS_KIT_APP_RECORDS__) != null ? _b4 : _a4.__VUE_DEVTOOLS_KIT_APP_RECORDS__ = [];
var _a5;
var _b5;
(_b5 = (_a5 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__) != null ? _b5 : _a5.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = {};
var _a6;
var _b6;
(_b6 = (_a6 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__) != null ? _b6 : _a6.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = "";
var _a7;
var _b7;
(_b7 = (_a7 = target).__VUE_DEVTOOLS_KIT_CUSTOM_TABS__) != null ? _b7 : _a7.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__ = [];
var _a8;
var _b8;
(_b8 = (_a8 = target).__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__) != null ? _b8 : _a8.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__ = [];
var STATE_KEY = "__VUE_DEVTOOLS_KIT_GLOBAL_STATE__";
function initStateFactory() {
return {
connected: false,
clientConnected: false,
vitePluginDetected: true,
appRecords: [],
activeAppRecordId: "",
tabs: [],
commands: [],
highPerfModeEnabled: true,
devtoolsClientDetected: {},
perfUniqueGroupId: 0,
timelineLayersState: getTimelineLayersStateFromStorage()
};
}
var _a9;
var _b9;
(_b9 = (_a9 = target)[STATE_KEY]) != null ? _b9 : _a9[STATE_KEY] = initStateFactory();
var callStateUpdatedHook = debounce((state) => {
devtoolsContext.hooks.callHook("devtoolsStateUpdated", { state });
});
var callConnectedUpdatedHook = debounce((state, oldState) => {
devtoolsContext.hooks.callHook("devtoolsConnectedUpdated", { state, oldState });
});
var devtoolsAppRecords = new Proxy(target.__VUE_DEVTOOLS_KIT_APP_RECORDS__, {
get(_target, prop, receiver) {
if (prop === "value")
return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__;
return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__[prop];
}
});
var activeAppRecord = new Proxy(target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__, {
get(_target, prop, receiver) {
if (prop === "value")
return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__;
else if (prop === "id")
return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__;
return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__[prop];
}
});
function updateAllStates() {
callStateUpdatedHook({
...target[STATE_KEY],
appRecords: devtoolsAppRecords.value,
activeAppRecordId: activeAppRecord.id,
tabs: target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__,
commands: target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__
});
}
function setActiveAppRecord(app) {
target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = app;
updateAllStates();
}
function setActiveAppRecordId(id) {
target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = id;
updateAllStates();
}
var devtoolsState = new Proxy(target[STATE_KEY], {
get(target22, property) {
if (property === "appRecords") {
return devtoolsAppRecords;
} else if (property === "activeAppRecordId") {
return activeAppRecord.id;
} else if (property === "tabs") {
return target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
} else if (property === "commands") {
return target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
}
return target[STATE_KEY][property];
},
deleteProperty(target22, property) {
delete target22[property];
return true;
},
set(target22, property, value) {
const oldState = { ...target[STATE_KEY] };
target22[property] = value;
target[STATE_KEY][property] = value;
return true;
}
});
function onDevToolsConnected(fn) {
return new Promise((resolve) => {
if (devtoolsState.connected) {
fn();
resolve();
}
devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
if (state.connected) {
fn();
resolve();
}
});
});
}
var resolveIcon = (icon) => {
if (!icon)
return;
if (icon.startsWith("baseline-")) {
return `custom-ic-${icon}`;
}
if (icon.startsWith("i-") || isUrlString(icon))
return icon;
return `custom-ic-baseline-${icon}`;
};
function addCustomTab(tab) {
const tabs = target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
if (tabs.some((t) => t.name === tab.name))
return;
tabs.push({
...tab,
icon: resolveIcon(tab.icon)
});
updateAllStates();
}
function addCustomCommand(action) {
const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
if (commands.some((t) => t.id === action.id))
return;
commands.push({
...action,
icon: resolveIcon(action.icon),
children: action.children ? action.children.map((child) => ({
...child,
icon: resolveIcon(child.icon)
})) : void 0
});
updateAllStates();
}
function removeCustomCommand(actionId) {
const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
const index = commands.findIndex((t) => t.id === actionId);
if (index === -1)
return;
commands.splice(index, 1);
updateAllStates();
}
function openInEditor(options = {}) {
var _a25, _b25, _c;
const { file, host, baseUrl = window.location.origin, line = 0, column = 0 } = options;
if (file) {
if (host === "chrome-extension") {
const fileName = file.replace(/\\/g, "\\\\");
const _baseUrl = (_b25 = (_a25 = window.VUE_DEVTOOLS_CONFIG) == null ? void 0 : _a25.openInEditorHost) != null ? _b25 : "/";
fetch(`${_baseUrl}__open-in-editor?file=${encodeURI(file)}`).then((response) => {
if (!response.ok) {
const msg = `Opening component ${fileName} failed`;
console.log(`%c${msg}`, "color:red");
}
});
} else if (devtoolsState.vitePluginDetected) {
const _baseUrl = (_c = target.__VUE_DEVTOOLS_OPEN_IN_EDITOR_BASE_URL__) != null ? _c : baseUrl;
target.__VUE_INSPECTOR__.openInEditor(_baseUrl, file, line, column);
}
}
}
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var _a10;
var _b10;
(_b10 = (_a10 = target).__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__) != null ? _b10 : _a10.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__ = [];
var devtoolsPluginBuffer = new Proxy(target.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__, {
get(target22, prop, receiver) {
return Reflect.get(target22, prop, receiver);
}
});
function _getSettings(settings) {
const _settings = {};
Object.keys(settings).forEach((key) => {
_settings[key] = settings[key].defaultValue;
});
return _settings;
}
function getPluginLocalKey(pluginId) {
return `__VUE_DEVTOOLS_NEXT_PLUGIN_SETTINGS__${pluginId}__`;
}
function getPluginSettingsOptions(pluginId) {
var _a25, _b25, _c;
const item = (_b25 = (_a25 = devtoolsPluginBuffer.find((item2) => {
var _a26;
return item2[0].id === pluginId && !!((_a26 = item2[0]) == null ? void 0 : _a26.settings);
})) == null ? void 0 : _a25[0]) != null ? _b25 : null;
return (_c = item == null ? void 0 : item.settings) != null ? _c : null;
}
function getPluginSettings(pluginId, fallbackValue) {
var _a25, _b25, _c;
const localKey = getPluginLocalKey(pluginId);
if (localKey) {
const localSettings = localStorage.getItem(localKey);
if (localSettings) {
return JSON.parse(localSettings);
}
}
if (pluginId) {
const item = (_b25 = (_a25 = devtoolsPluginBuffer.find((item2) => item2[0].id === pluginId)) == null ? void 0 : _a25[0]) != null ? _b25 : null;
return _getSettings((_c = item == null ? void 0 : item.settings) != null ? _c : {});
}
return _getSettings(fallbackValue);
}
function initPluginSettings(pluginId, settings) {
const localKey = getPluginLocalKey(pluginId);
const localSettings = localStorage.getItem(localKey);
if (!localSettings) {
localStorage.setItem(localKey, JSON.stringify(_getSettings(settings)));
}
}
function setPluginSettings(pluginId, key, value) {
const localKey = getPluginLocalKey(pluginId);
const localSettings = localStorage.getItem(localKey);
const parsedLocalSettings = JSON.parse(localSettings || "{}");
const updated = {
...parsedLocalSettings,
[key]: value
};
localStorage.setItem(localKey, JSON.stringify(updated));
devtoolsContext.hooks.callHookWith(
(callbacks) => {
callbacks.forEach((cb) => cb({
pluginId,
key,
oldValue: parsedLocalSettings[key],
newValue: value,
settings: updated
}));
},
"setPluginSettings"
/* SET_PLUGIN_SETTINGS */
);
}
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var _a11;
var _b11;
var devtoolsHooks = (_b11 = (_a11 = target).__VUE_DEVTOOLS_HOOK) != null ? _b11 : _a11.__VUE_DEVTOOLS_HOOK = createHooks();
var on = {
vueAppInit(fn) {
devtoolsHooks.hook("app:init", fn);
},
vueAppUnmount(fn) {
devtoolsHooks.hook("app:unmount", fn);
},
vueAppConnected(fn) {
devtoolsHooks.hook("app:connected", fn);
},
componentAdded(fn) {
return devtoolsHooks.hook("component:added", fn);
},
componentEmit(fn) {
return devtoolsHooks.hook("component:emit", fn);
},
componentUpdated(fn) {
return devtoolsHooks.hook("component:updated", fn);
},
componentRemoved(fn) {
return devtoolsHooks.hook("component:removed", fn);
},
setupDevtoolsPlugin(fn) {
devtoolsHooks.hook("devtools-plugin:setup", fn);
},
perfStart(fn) {
return devtoolsHooks.hook("perf:start", fn);
},
perfEnd(fn) {
return devtoolsHooks.hook("perf:end", fn);
}
};
var hook = {
on,
setupDevToolsPlugin(pluginDescriptor, setupFn) {
return devtoolsHooks.callHook("devtools-plugin:setup", pluginDescriptor, setupFn);
}
};
var DevToolsV6PluginAPI = class {
constructor({ plugin, ctx }) {
this.hooks = ctx.hooks;
this.plugin = plugin;
}
get on() {
return {
// component inspector
visitComponentTree: (handler) => {
this.hooks.hook("visitComponentTree", handler);
},
inspectComponent: (handler) => {
this.hooks.hook("inspectComponent", handler);
},
editComponentState: (handler) => {
this.hooks.hook("editComponentState", handler);
},
// custom inspector
getInspectorTree: (handler) => {
this.hooks.hook("getInspectorTree", handler);
},
getInspectorState: (handler) => {
this.hooks.hook("getInspectorState", handler);
},
editInspectorState: (handler) => {
this.hooks.hook("editInspectorState", handler);
},
// timeline
inspectTimelineEvent: (handler) => {
this.hooks.hook("inspectTimelineEvent", handler);
},
timelineCleared: (handler) => {
this.hooks.hook("timelineCleared", handler);
},
// settings
setPluginSettings: (handler) => {
this.hooks.hook("setPluginSettings", handler);
}
};
}
// component inspector
notifyComponentUpdate(instance) {
var _a25;
if (devtoolsState.highPerfModeEnabled) {
return;
}
const inspector = getActiveInspectors().find((i) => i.packageName === this.plugin.descriptor.packageName);
if (inspector == null ? void 0 : inspector.id) {
if (instance) {
const args = [
instance.appContext.app,
instance.uid,
(_a25 = instance.parent) == null ? void 0 : _a25.uid,
instance
];
devtoolsHooks.callHook("component:updated", ...args);
} else {
devtoolsHooks.callHook(
"component:updated"
/* COMPONENT_UPDATED */
);
}
this.hooks.callHook("sendInspectorState", { inspectorId: inspector.id, plugin: this.plugin });
}
}
// custom inspector
addInspector(options) {
this.hooks.callHook("addInspector", { inspector: options, plugin: this.plugin });
if (this.plugin.descriptor.settings) {
initPluginSettings(options.id, this.plugin.descriptor.settings);
}
}
sendInspectorTree(inspectorId) {
if (devtoolsState.highPerfModeEnabled) {
return;
}
this.hooks.callHook("sendInspectorTree", { inspectorId, plugin: this.plugin });
}
sendInspectorState(inspectorId) {
if (devtoolsState.highPerfModeEnabled) {
return;
}
this.hooks.callHook("sendInspectorState", { inspectorId, plugin: this.plugin });
}
selectInspectorNode(inspectorId, nodeId) {
this.hooks.callHook("customInspectorSelectNode", { inspectorId, nodeId, plugin: this.plugin });
}
visitComponentTree(payload) {
return this.hooks.callHook("visitComponentTree", payload);
}
// timeline
now() {
if (devtoolsState.highPerfModeEnabled) {
return 0;
}
return Date.now();
}
addTimelineLayer(options) {
this.hooks.callHook("timelineLayerAdded", { options, plugin: this.plugin });
}
addTimelineEvent(options) {
if (devtoolsState.highPerfModeEnabled) {
return;
}
this.hooks.callHook("timelineEventAdded", { options, plugin: this.plugin });
}
// settings
getSettings(pluginId) {
return getPluginSettings(pluginId != null ? pluginId : this.plugin.descriptor.id, this.plugin.descriptor.settings);
}
// utilities
getComponentInstances(app) {
return this.hooks.callHook("getComponentInstances", { app });
}
getComponentBounds(instance) {
return this.hooks.callHook("getComponentBounds", { instance });
}
getComponentName(instance) {
return this.hooks.callHook("getComponentName", { instance });
}
highlightElement(instance) {
const uid = instance.__VUE_DEVTOOLS_NEXT_UID__;
return this.hooks.callHook("componentHighlight", { uid });
}
unhighlightElement() {
return this.hooks.callHook(
"componentUnhighlight"
/* COMPONENT_UNHIGHLIGHT */
);
}
};
var DevToolsPluginAPI = DevToolsV6PluginAPI;
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var UNDEFINED = "__vue_devtool_undefined__";
var INFINITY = "__vue_devtool_infinity__";
var NEGATIVE_INFINITY = "__vue_devtool_negative_infinity__";
var NAN = "__vue_devtool_nan__";
init_esm_shims2();
init_esm_shims2();
var tokenMap = {
[UNDEFINED]: "undefined",
[NAN]: "NaN",
[INFINITY]: "Infinity",
[NEGATIVE_INFINITY]: "-Infinity"
};
var reversedTokenMap = Object.entries(tokenMap).reduce((acc, [key, value]) => {
acc[value] = key;
return acc;
}, {});
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var _a12;
var _b12;
(_b12 = (_a12 = target).__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__) != null ? _b12 : _a12.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__ = /* @__PURE__ */ new Set();
function setupDevToolsPlugin(pluginDescriptor, setupFn) {
return hook.setupDevToolsPlugin(pluginDescriptor, setupFn);
}
function callDevToolsPluginSetupFn(plugin, app) {
const [pluginDescriptor, setupFn] = plugin;
if (pluginDescriptor.app !== app)
return;
const api = new DevToolsPluginAPI({
plugin: {
setupFn,
descriptor: pluginDescriptor
},
ctx: devtoolsContext
});
if (pluginDescriptor.packageName === "vuex") {
api.on.editInspectorState((payload) => {
api.sendInspectorState(payload.inspectorId);
});
}
setupFn(api);
}
function registerDevToolsPlugin(app, options) {
if (target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.has(app)) {
return;
}
if (devtoolsState.highPerfModeEnabled && !(options == null ? void 0 : options.inspectingComponent)) {
return;
}
target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.add(app);
devtoolsPluginBuffer.forEach((plugin) => {
callDevToolsPluginSetupFn(plugin, app);
});
}
init_esm_shims2();
init_esm_shims2();
var ROUTER_KEY = "__VUE_DEVTOOLS_ROUTER__";
var ROUTER_INFO_KEY = "__VUE_DEVTOOLS_ROUTER_INFO__";
var _a13;
var _b13;
(_b13 = (_a13 = target)[ROUTER_INFO_KEY]) != null ? _b13 : _a13[ROUTER_INFO_KEY] = {
currentRoute: null,
routes: []
};
var _a14;
var _b14;
(_b14 = (_a14 = target)[ROUTER_KEY]) != null ? _b14 : _a14[ROUTER_KEY] = {};
var devtoolsRouterInfo = new Proxy(target[ROUTER_INFO_KEY], {
get(target22, property) {
return target[ROUTER_INFO_KEY][property];
}
});
var devtoolsRouter = new Proxy(target[ROUTER_KEY], {
get(target22, property) {
if (property === "value") {
return target[ROUTER_KEY];
}
}
});
function getRoutes(router) {
const routesMap = /* @__PURE__ */ new Map();
return ((router == null ? void 0 : router.getRoutes()) || []).filter((i) => !routesMap.has(i.path) && routesMap.set(i.path, 1));
}
function filterRoutes(routes) {
return routes.map((item) => {
let { path, name, children, meta } = item;
if (children == null ? void 0 : children.length)
children = filterRoutes(children);
return {
path,
name,
children,
meta
};
});
}
function filterCurrentRoute(route) {
if (route) {
const { fullPath, hash, href, path, name, matched, params, query } = route;
return {
fullPath,
hash,
href,
path,
name,
params,
query,
matched: filterRoutes(matched)
};
}
return route;
}
function normalizeRouterInfo(appRecord, activeAppRecord2) {
function init() {
var _a25;
const router = (_a25 = appRecord.app) == null ? void 0 : _a25.config.globalProperties.$router;
const currentRoute = filterCurrentRoute(router == null ? void 0 : router.currentRoute.value);
const routes = filterRoutes(getRoutes(router));
const c = console.warn;
console.warn = () => {
};
target[ROUTER_INFO_KEY] = {
currentRoute: currentRoute ? deepClone(currentRoute) : {},
routes: deepClone(routes)
};
target[ROUTER_KEY] = router;
console.warn = c;
}
init();
hook.on.componentUpdated(debounce(() => {
var _a25;
if (((_a25 = activeAppRecord2.value) == null ? void 0 : _a25.app) !== appRecord.app)
return;
init();
if (devtoolsState.highPerfModeEnabled)
return;
devtoolsContext.hooks.callHook("routerInfoUpdated", { state: target[ROUTER_INFO_KEY] });
}, 200));
}
function createDevToolsApi(hooks2) {
return {
// get inspector tree
async getInspectorTree(payload) {
const _payload = {
...payload,
app: activeAppRecord.value.app,
rootNodes: []
};
await new Promise((resolve) => {
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb(_payload)));
resolve();
},
"getInspectorTree"
/* GET_INSPECTOR_TREE */
);
});
return _payload.rootNodes;
},
// get inspector state
async getInspectorState(payload) {
const _payload = {
...payload,
app: activeAppRecord.value.app,
state: null
};
const ctx = {
currentTab: `custom-inspector:${payload.inspectorId}`
};
await new Promise((resolve) => {
hooks2.callHookWith(
async (callbacks) => {
await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
resolve();
},
"getInspectorState"
/* GET_INSPECTOR_STATE */
);
});
return _payload.state;
},
// edit inspector state
editInspectorState(payload) {
const stateEditor2 = new StateEditor();
const _payload = {
...payload,
app: activeAppRecord.value.app,
set: (obj, path = payload.path, value = payload.state.value, cb) => {
stateEditor2.set(obj, path, value, cb || stateEditor2.createDefaultSetCallback(payload.state));
}
};
hooks2.callHookWith(
(callbacks) => {
callbacks.forEach((cb) => cb(_payload));
},
"editInspectorState"
/* EDIT_INSPECTOR_STATE */
);
},
// send inspector state
sendInspectorState(inspectorId) {
const inspector = getInspector(inspectorId);
hooks2.callHook("sendInspectorState", { inspectorId, plugin: {
descriptor: inspector.descriptor,
setupFn: () => ({})
} });
},
// inspect component inspector
inspectComponentInspector() {
return inspectComponentHighLighter();
},
// cancel inspect component inspector
cancelInspectComponentInspector() {
return cancelInspectComponentHighLighter();
},
// get component render code
getComponentRenderCode(id) {
const instance = getComponentInstance(activeAppRecord.value, id);
if (instance)
return !(typeof (instance == null ? void 0 : instance.type) === "function") ? instance.render.toString() : instance.type.toString();
},
// scroll to component
scrollToComponent(id) {
return scrollToComponent({ id });
},
// open in editor
openInEditor,
// get vue inspector
getVueInspector: getComponentInspector,
// toggle app
toggleApp(id, options) {
const appRecord = devtoolsAppRecords.value.find((record) => record.id === id);
if (appRecord) {
setActiveAppRecordId(id);
setActiveAppRecord(appRecord);
normalizeRouterInfo(appRecord, activeAppRecord);
callInspectorUpdatedHook();
registerDevToolsPlugin(appRecord.app, options);
}
},
// inspect dom
inspectDOM(instanceId) {
const instance = getComponentInstance(activeAppRecord.value, instanceId);
if (instance) {
const [el] = getRootElementsFromComponentInstance(instance);
if (el) {
target.__VUE_DEVTOOLS_INSPECT_DOM_TARGET__ = el;
}
}
},
updatePluginSettings(pluginId, key, value) {
setPluginSettings(pluginId, key, value);
},
getPluginSettings(pluginId) {
return {
options: getPluginSettingsOptions(pluginId),
values: getPluginSettings(pluginId)
};
}
};
}
init_esm_shims2();
var _a15;
var _b15;
(_b15 = (_a15 = target).__VUE_DEVTOOLS_ENV__) != null ? _b15 : _a15.__VUE_DEVTOOLS_ENV__ = {
vitePluginDetected: false
};
var hooks = createDevToolsCtxHooks();
var _a16;
var _b16;
(_b16 = (_a16 = target).__VUE_DEVTOOLS_KIT_CONTEXT__) != null ? _b16 : _a16.__VUE_DEVTOOLS_KIT_CONTEXT__ = {
hooks,
get state() {
return {
...devtoolsState,
activeAppRecordId: activeAppRecord.id,
activeAppRecord: activeAppRecord.value,
appRecords: devtoolsAppRecords.value
};
},
api: createDevToolsApi(hooks)
};
var devtoolsContext = target.__VUE_DEVTOOLS_KIT_CONTEXT__;
init_esm_shims2();
var import_speakingurl = __toESM2(require_speakingurl2(), 1);
var _a17;
var _b17;
var appRecordInfo = (_b17 = (_a17 = target).__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__) != null ? _b17 : _a17.__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__ = {
id: 0,
appIds: /* @__PURE__ */ new Set()
};
init_esm_shims2();
function onDevToolsClientConnected(fn) {
return new Promise((resolve) => {
if (devtoolsState.connected && devtoolsState.clientConnected) {
fn();
resolve();
return;
}
devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
if (state.connected && state.clientConnected) {
fn();
resolve();
}
});
});
}
init_esm_shims2();
function toggleHighPerfMode(state) {
devtoolsState.highPerfModeEnabled = state != null ? state : !devtoolsState.highPerfModeEnabled;
if (!state && activeAppRecord.value) {
registerDevToolsPlugin(activeAppRecord.value.app);
}
}
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
function updateDevToolsClientDetected(params) {
devtoolsState.devtoolsClientDetected = {
...devtoolsState.devtoolsClientDetected,
...params
};
const devtoolsClientVisible = Object.values(devtoolsState.devtoolsClientDetected).some(Boolean);
toggleHighPerfMode(!devtoolsClientVisible);
}
var _a18;
var _b18;
(_b18 = (_a18 = target).__VUE_DEVTOOLS_UPDATE_CLIENT_DETECTED__) != null ? _b18 : _a18.__VUE_DEVTOOLS_UPDATE_CLIENT_DETECTED__ = updateDevToolsClientDetected;
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var DoubleIndexedKV = class {
constructor() {
this.keyToValue = /* @__PURE__ */ new Map();
this.valueToKey = /* @__PURE__ */ new Map();
}
set(key, value) {
this.keyToValue.set(key, value);
this.valueToKey.set(value, key);
}
getByKey(key) {
return this.keyToValue.get(key);
}
getByValue(value) {
return this.valueToKey.get(value);
}
clear() {
this.keyToValue.clear();
this.valueToKey.clear();
}
};
var Registry = class {
constructor(generateIdentifier) {
this.generateIdentifier = generateIdentifier;
this.kv = new DoubleIndexedKV();
}
register(value, identifier) {
if (this.kv.getByValue(value)) {
return;
}
if (!identifier) {
identifier = this.generateIdentifier(value);
}
this.kv.set(identifier, value);
}
clear() {
this.kv.clear();
}
getIdentifier(value) {
return this.kv.getByValue(value);
}
getValue(identifier) {
return this.kv.getByKey(identifier);
}
};
var ClassRegistry = class extends Registry {
constructor() {
super((c) => c.name);
this.classToAllowedProps = /* @__PURE__ */ new Map();
}
register(value, options) {
if (typeof options === "object") {
if (options.allowProps) {
this.classToAllowedProps.set(value, options.allowProps);
}
super.register(value, options.identifier);
} else {
super.register(value, options);
}
}
getAllowedProps(value) {
return this.classToAllowedProps.get(value);
}
};
init_esm_shims2();
init_esm_shims2();
function valuesOfObj(record) {
if ("values" in Object) {
return Object.values(record);
}
const values = [];
for (const key in record) {
if (record.hasOwnProperty(key)) {
values.push(record[key]);
}
}
return values;
}
function find(record, predicate) {
const values = valuesOfObj(record);
if ("find" in values) {
return values.find(predicate);
}
const valuesNotNever = values;
for (let i = 0; i < valuesNotNever.length; i++) {
const value = valuesNotNever[i];
if (predicate(value)) {
return value;
}
}
return void 0;
}
function forEach(record, run) {
Object.entries(record).forEach(([key, value]) => run(value, key));
}
function includes(arr, value) {
return arr.indexOf(value) !== -1;
}
function findArr(record, predicate) {
for (let i = 0; i < record.length; i++) {
const value = record[i];
if (predicate(value)) {
return value;
}
}
return void 0;
}
var CustomTransformerRegistry = class {
constructor() {
this.transfomers = {};
}
register(transformer) {
this.transfomers[transformer.name] = transformer;
}
findApplicable(v) {
return find(this.transfomers, (transformer) => transformer.isApplicable(v));
}
findByName(name) {
return this.transfomers[name];
}
};
init_esm_shims2();
init_esm_shims2();
var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
var isUndefined = (payload) => typeof payload === "undefined";
var isNull = (payload) => payload === null;
var isPlainObject2 = (payload) => {
if (typeof payload !== "object" || payload === null)
return false;
if (payload === Object.prototype)
return false;
if (Object.getPrototypeOf(payload) === null)
return true;
return Object.getPrototypeOf(payload) === Object.prototype;
};
var isEmptyObject = (payload) => isPlainObject2(payload) && Object.keys(payload).length === 0;
var isArray = (payload) => Array.isArray(payload);
var isString = (payload) => typeof payload === "string";
var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
var isBoolean = (payload) => typeof payload === "boolean";
var isRegExp = (payload) => payload instanceof RegExp;
var isMap = (payload) => payload instanceof Map;
var isSet = (payload) => payload instanceof Set;
var isSymbol = (payload) => getType(payload) === "Symbol";
var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
var isError = (payload) => payload instanceof Error;
var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
var isPrimitive2 = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
var isBigint = (payload) => typeof payload === "bigint";
var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
var isURL = (payload) => payload instanceof URL;
init_esm_shims2();
var escapeKey = (key) => key.replace(/\./g, "\\.");
var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
var parsePath = (string) => {
const result = [];
let segment = "";
for (let i = 0; i < string.length; i++) {
let char = string.charAt(i);
const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
if (isEscapedDot) {
segment += ".";
i++;
continue;
}
const isEndOfSegment = char === ".";
if (isEndOfSegment) {
result.push(segment);
segment = "";
continue;
}
segment += char;
}
const lastSegment = segment;
result.push(lastSegment);
return result;
};
init_esm_shims2();
function simpleTransformation(isApplicable, annotation, transform, untransform) {
return {
isApplicable,
annotation,
transform,
untransform
};
}
var simpleRules = [
simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
if (typeof BigInt !== "undefined") {
return BigInt(v);
}
console.error("Please add a BigInt polyfill.");
return v;
}),
simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
simpleTransformation(isError, "Error", (v, superJson) => {
const baseError = {
name: v.name,
message: v.message
};
superJson.allowedErrorProps.forEach((prop) => {
baseError[prop] = v[prop];
});
return baseError;
}, (v, superJson) => {
const e = new Error(v.message);
e.name = v.name;
e.stack = v.stack;
superJson.allowedErrorProps.forEach((prop) => {
e[prop] = v[prop];
});
return e;
}),
simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
const body = regex.slice(1, regex.lastIndexOf("/"));
const flags = regex.slice(regex.lastIndexOf("/") + 1);
return new RegExp(body, flags);
}),
simpleTransformation(
isSet,
"set",
// (sets only exist in es6+)
// eslint-disable-next-line es5/no-es6-methods
(v) => [...v.values()],
(v) => new Set(v)
),
simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
if (isNaNValue(v)) {
return "NaN";
}
if (v > 0) {
return "Infinity";
} else {
return "-Infinity";
}
}, Number),
simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
return "-0";
}, Number),
simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
];
function compositeTransformation(isApplicable, annotation, transform, untransform) {
return {
isApplicable,
annotation,
transform,
untransform
};
}
var symbolRule = compositeTransformation((s, superJson) => {
if (isSymbol(s)) {
const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
return isRegistered;
}
return false;
}, (s, superJson) => {
const identifier = superJson.symbolRegistry.getIdentifier(s);
return ["symbol", identifier];
}, (v) => v.description, (_, a, superJson) => {
const value = superJson.symbolRegistry.getValue(a[1]);
if (!value) {
throw new Error("Trying to deserialize unknown symbol");
}
return value;
});
var constructorToName = [
Int8Array,
Uint8Array,
Int16Array,
Uint16Array,
Int32Array,
Uint32Array,
Float32Array,
Float64Array,
Uint8ClampedArray
].reduce((obj, ctor) => {
obj[ctor.name] = ctor;
return obj;
}, {});
var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
const ctor = constructorToName[a[1]];
if (!ctor) {
throw new Error("Trying to deserialize unknown typed array");
}
return new ctor(v);
});
function isInstanceOfRegisteredClass(potentialClass, superJson) {
if (potentialClass == null ? void 0 : potentialClass.constructor) {
const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
return isRegistered;
}
return false;
}
var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
return ["class", identifier];
}, (clazz, superJson) => {
const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
if (!allowedProps) {
return { ...clazz };
}
const result = {};
allowedProps.forEach((prop) => {
result[prop] = clazz[prop];
});
return result;
}, (v, a, superJson) => {
const clazz = superJson.classRegistry.getValue(a[1]);
if (!clazz) {
throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
}
return Object.assign(Object.create(clazz.prototype), v);
});
var customRule = compositeTransformation((value, superJson) => {
return !!superJson.customTransformerRegistry.findApplicable(value);
}, (value, superJson) => {
const transformer = superJson.customTransformerRegistry.findApplicable(value);
return ["custom", transformer.name];
}, (value, superJson) => {
const transformer = superJson.customTransformerRegistry.findApplicable(value);
return transformer.serialize(value);
}, (v, a, superJson) => {
const transformer = superJson.customTransformerRegistry.findByName(a[1]);
if (!transformer) {
throw new Error("Trying to deserialize unknown custom value");
}
return transformer.deserialize(v);
});
var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
var transformValue = (value, superJson) => {
const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
if (applicableCompositeRule) {
return {
value: applicableCompositeRule.transform(value, superJson),
type: applicableCompositeRule.annotation(value, superJson)
};
}
const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
if (applicableSimpleRule) {
return {
value: applicableSimpleRule.transform(value, superJson),
type: applicableSimpleRule.annotation
};
}
return void 0;
};
var simpleRulesByAnnotation = {};
simpleRules.forEach((rule) => {
simpleRulesByAnnotation[rule.annotation] = rule;
});
var untransformValue = (json, type, superJson) => {
if (isArray(type)) {
switch (type[0]) {
case "symbol":
return symbolRule.untransform(json, type, superJson);
case "class":
return classRule.untransform(json, type, superJson);
case "custom":
return customRule.untransform(json, type, superJson);
case "typed-array":
return typedArrayRule.untransform(json, type, superJson);
default:
throw new Error("Unknown transformation: " + type);
}
} else {
const transformation = simpleRulesByAnnotation[type];
if (!transformation) {
throw new Error("Unknown transformation: " + type);
}
return transformation.untransform(json, superJson);
}
};
init_esm_shims2();
var getNthKey = (value, n) => {
if (n > value.size)
throw new Error("index out of bounds");
const keys = value.keys();
while (n > 0) {
keys.next();
n--;
}
return keys.next().value;
};
function validatePath(path) {
if (includes(path, "__proto__")) {
throw new Error("__proto__ is not allowed as a property");
}
if (includes(path, "prototype")) {
throw new Error("prototype is not allowed as a property");
}
if (includes(path, "constructor")) {
throw new Error("constructor is not allowed as a property");
}
}
var getDeep = (object, path) => {
validatePath(path);
for (let i = 0; i < path.length; i++) {
const key = path[i];
if (isSet(object)) {
object = getNthKey(object, +key);
} else if (isMap(object)) {
const row = +key;
const type = +path[++i] === 0 ? "key" : "value";
const keyOfRow = getNthKey(object, row);
switch (type) {
case "key":
object = keyOfRow;
break;
case "value":
object = object.get(keyOfRow);
break;
}
} else {
object = object[key];
}
}
return object;
};
var setDeep = (object, path, mapper) => {
validatePath(path);
if (path.length === 0) {
return mapper(object);
}
let parent = object;
for (let i = 0; i < path.length - 1; i++) {
const key = path[i];
if (isArray(parent)) {
const index = +key;
parent = parent[index];
} else if (isPlainObject2(parent)) {
parent = parent[key];
} else if (isSet(parent)) {
const row = +key;
parent = getNthKey(parent, row);
} else if (isMap(parent)) {
const isEnd = i === path.length - 2;
if (isEnd) {
break;
}
const row = +key;
const type = +path[++i] === 0 ? "key" : "value";
const keyOfRow = getNthKey(parent, row);
switch (type) {
case "key":
parent = keyOfRow;
break;
case "value":
parent = parent.get(keyOfRow);
break;
}
}
}
const lastKey = path[path.length - 1];
if (isArray(parent)) {
parent[+lastKey] = mapper(parent[+lastKey]);
} else if (isPlainObject2(parent)) {
parent[lastKey] = mapper(parent[lastKey]);
}
if (isSet(parent)) {
const oldValue = getNthKey(parent, +lastKey);
const newValue = mapper(oldValue);
if (oldValue !== newValue) {
parent.delete(oldValue);
parent.add(newValue);
}
}
if (isMap(parent)) {
const row = +path[path.length - 2];
const keyToRow = getNthKey(parent, row);
const type = +lastKey === 0 ? "key" : "value";
switch (type) {
case "key": {
const newKey = mapper(keyToRow);
parent.set(newKey, parent.get(keyToRow));
if (newKey !== keyToRow) {
parent.delete(keyToRow);
}
break;
}
case "value": {
parent.set(keyToRow, mapper(parent.get(keyToRow)));
break;
}
}
}
return object;
};
function traverse(tree, walker2, origin = []) {
if (!tree) {
return;
}
if (!isArray(tree)) {
forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
return;
}
const [nodeValue, children] = tree;
if (children) {
forEach(children, (child, key) => {
traverse(child, walker2, [...origin, ...parsePath(key)]);
});
}
walker2(nodeValue, origin);
}
function applyValueAnnotations(plain, annotations, superJson) {
traverse(annotations, (type, path) => {
plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
});
return plain;
}
function applyReferentialEqualityAnnotations(plain, annotations) {
function apply(identicalPaths, path) {
const object = getDeep(plain, parsePath(path));
identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
plain = setDeep(plain, identicalObjectPath, () => object);
});
}
if (isArray(annotations)) {
const [root, other] = annotations;
root.forEach((identicalPath) => {
plain = setDeep(plain, parsePath(identicalPath), () => plain);
});
if (other) {
forEach(other, apply);
}
} else {
forEach(annotations, apply);
}
return plain;
}
var isDeep = (object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
function addIdentity(object, path, identities) {
const existingSet = identities.get(object);
if (existingSet) {
existingSet.push(path);
} else {
identities.set(object, [path]);
}
}
function generateReferentialEqualityAnnotations(identitites, dedupe) {
const result = {};
let rootEqualityPaths = void 0;
identitites.forEach((paths) => {
if (paths.length <= 1) {
return;
}
if (!dedupe) {
paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
}
const [representativePath, ...identicalPaths] = paths;
if (representativePath.length === 0) {
rootEqualityPaths = identicalPaths.map(stringifyPath);
} else {
result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
}
});
if (rootEqualityPaths) {
if (isEmptyObject(result)) {
return [rootEqualityPaths];
} else {
return [rootEqualityPaths, result];
}
} else {
return isEmptyObject(result) ? void 0 : result;
}
}
var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
var _a25;
const primitive = isPrimitive2(object);
if (!primitive) {
addIdentity(object, path, identities);
const seen = seenObjects.get(object);
if (seen) {
return dedupe ? {
transformedValue: null
} : seen;
}
}
if (!isDeep(object, superJson)) {
const transformed2 = transformValue(object, superJson);
const result2 = transformed2 ? {
transformedValue: transformed2.value,
annotations: [transformed2.type]
} : {
transformedValue: object
};
if (!primitive) {
seenObjects.set(object, result2);
}
return result2;
}
if (includes(objectsInThisPath, object)) {
return {
transformedValue: null
};
}
const transformationResult = transformValue(object, superJson);
const transformed = (_a25 = transformationResult == null ? void 0 : transformationResult.value) != null ? _a25 : object;
const transformedValue = isArray(transformed) ? [] : {};
const innerAnnotations = {};
forEach(transformed, (value, index) => {
if (index === "__proto__" || index === "constructor" || index === "prototype") {
throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
}
const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
transformedValue[index] = recursiveResult.transformedValue;
if (isArray(recursiveResult.annotations)) {
innerAnnotations[index] = recursiveResult.annotations;
} else if (isPlainObject2(recursiveResult.annotations)) {
forEach(recursiveResult.annotations, (tree, key) => {
innerAnnotations[escapeKey(index) + "." + key] = tree;
});
}
});
const result = isEmptyObject(innerAnnotations) ? {
transformedValue,
annotations: !!transformationResult ? [transformationResult.type] : void 0
} : {
transformedValue,
annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
};
if (!primitive) {
seenObjects.set(object, result);
}
return result;
};
init_esm_shims2();
init_esm_shims2();
function getType2(payload) {
return Object.prototype.toString.call(payload).slice(8, -1);
}
function isArray2(payload) {
return getType2(payload) === "Array";
}
function isPlainObject3(payload) {
if (getType2(payload) !== "Object")
return false;
const prototype = Object.getPrototypeOf(payload);
return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
}
function isNull2(payload) {
return getType2(payload) === "Null";
}
function isOneOf(a, b, c, d, e) {
return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
}
function isUndefined2(payload) {
return getType2(payload) === "Undefined";
}
var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
if (propType === "enumerable")
carry[key] = newVal;
if (includeNonenumerable && propType === "nonenumerable") {
Object.defineProperty(carry, key, {
value: newVal,
enumerable: false,
writable: true,
configurable: true
});
}
}
function copy(target22, options = {}) {
if (isArray2(target22)) {
return target22.map((item) => copy(item, options));
}
if (!isPlainObject3(target22)) {
return target22;
}
const props = Object.getOwnPropertyNames(target22);
const symbols = Object.getOwnPropertySymbols(target22);
return [...props, ...symbols].reduce((carry, key) => {
if (isArray2(options.props) && !options.props.includes(key)) {
return carry;
}
const val = target22[key];
const newVal = copy(val, options);
assignProp(carry, key, newVal, target22, options.nonenumerable);
return carry;
}, {});
}
var SuperJSON = class {
/**
* @param dedupeReferentialEqualities If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
*/
constructor({ dedupe = false } = {}) {
this.classRegistry = new ClassRegistry();
this.symbolRegistry = new Registry((s) => {
var _a25;
return (_a25 = s.description) != null ? _a25 : "";
});
this.customTransformerRegistry = new CustomTransformerRegistry();
this.allowedErrorProps = [];
this.dedupe = dedupe;
}
serialize(object) {
const identities = /* @__PURE__ */ new Map();
const output = walker(object, identities, this, this.dedupe);
const res = {
json: output.transformedValue
};
if (output.annotations) {
res.meta = {
...res.meta,
values: output.annotations
};
}
const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
if (equalityAnnotations) {
res.meta = {
...res.meta,
referentialEqualities: equalityAnnotations
};
}
return res;
}
deserialize(payload) {
const { json, meta } = payload;
let result = copy(json);
if (meta == null ? void 0 : meta.values) {
result = applyValueAnnotations(result, meta.values, this);
}
if (meta == null ? void 0 : meta.referentialEqualities) {
result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
}
return result;
}
stringify(object) {
return JSON.stringify(this.serialize(object));
}
parse(string) {
return this.deserialize(JSON.parse(string));
}
registerClass(v, options) {
this.classRegistry.register(v, options);
}
registerSymbol(v, identifier) {
this.symbolRegistry.register(v, identifier);
}
registerCustom(transformer, name) {
this.customTransformerRegistry.register({
name,
...transformer
});
}
allowErrorProps(...props) {
this.allowedErrorProps.push(...props);
}
};
SuperJSON.defaultInstance = new SuperJSON();
SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
var serialize = SuperJSON.serialize;
var deserialize = SuperJSON.deserialize;
var stringify = SuperJSON.stringify;
var parse = SuperJSON.parse;
var registerClass = SuperJSON.registerClass;
var registerCustom = SuperJSON.registerCustom;
var registerSymbol = SuperJSON.registerSymbol;
var allowErrorProps = SuperJSON.allowErrorProps;
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var _a19;
var _b19;
(_b19 = (_a19 = target).__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__) != null ? _b19 : _a19.__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__ = [];
var _a20;
var _b20;
(_b20 = (_a20 = target).__VUE_DEVTOOLS_KIT_RPC_CLIENT__) != null ? _b20 : _a20.__VUE_DEVTOOLS_KIT_RPC_CLIENT__ = null;
var _a21;
var _b21;
(_b21 = (_a21 = target).__VUE_DEVTOOLS_KIT_RPC_SERVER__) != null ? _b21 : _a21.__VUE_DEVTOOLS_KIT_RPC_SERVER__ = null;
var _a222;
var _b22;
(_b22 = (_a222 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__) != null ? _b22 : _a222.__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__ = null;
var _a23;
var _b23;
(_b23 = (_a23 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__) != null ? _b23 : _a23.__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__ = null;
var _a24;
var _b24;
(_b24 = (_a24 = target).__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__) != null ? _b24 : _a24.__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__ = null;
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
init_esm_shims2();
var MAX_SERIALIZED_SIZE = 2 * 1024 * 1024;
export {
addCustomCommand,
addCustomTab,
onDevToolsClientConnected,
onDevToolsConnected,
removeCustomCommand,
setupDevToolsPlugin,
setupDevToolsPlugin as setupDevtoolsPlugin
};
//# sourceMappingURL=vitepress___@vue_devtools-api.js.map
```