Merge remote-tracking branch 'origin/main' into feat/model-plugins-implementing

api/tests/unit_tests/services/test_advanced_prompt_template_service.py

@@ -0,0 +1,214 @@
+"""
+Unit tests for services.advanced_prompt_template_service
+"""
+
+import copy
+
+from core.prompt.prompt_templates.advanced_prompt_templates import (
+    BAICHUAN_CHAT_APP_CHAT_PROMPT_CONFIG,
+    BAICHUAN_CHAT_APP_COMPLETION_PROMPT_CONFIG,
+    BAICHUAN_COMPLETION_APP_CHAT_PROMPT_CONFIG,
+    BAICHUAN_COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
+    BAICHUAN_CONTEXT,
+    CHAT_APP_CHAT_PROMPT_CONFIG,
+    CHAT_APP_COMPLETION_PROMPT_CONFIG,
+    COMPLETION_APP_CHAT_PROMPT_CONFIG,
+    COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
+    CONTEXT,
+)
+from models.model import AppMode
+from services.advanced_prompt_template_service import AdvancedPromptTemplateService
+
+
+class TestAdvancedPromptTemplateService:
+    """Test suite for AdvancedPromptTemplateService."""
+
+    def test_get_prompt_should_use_baichuan_prompt_when_model_name_contains_baichuan(self) -> None:
+        """Test baichuan model names use baichuan context prompt."""
+        # Arrange
+        args = {
+            "app_mode": AppMode.CHAT,
+            "model_mode": "chat",
+            "model_name": "Baichuan2-13B",
+            "has_context": "true",
+        }
+
+        # Act
+        result = AdvancedPromptTemplateService.get_prompt(args)
+
+        # Assert
+        assert result["chat_prompt_config"]["prompt"][0]["text"].startswith(BAICHUAN_CONTEXT)
+
+    def test_get_prompt_should_use_common_prompt_when_model_name_not_baichuan(self) -> None:
+        """Test non-baichuan model names use common prompt."""
+        # Arrange
+        args = {
+            "app_mode": AppMode.CHAT,
+            "model_mode": "completion",
+            "model_name": "gpt-4",
+            "has_context": "false",
+        }
+        original_config = copy.deepcopy(CHAT_APP_COMPLETION_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_prompt(args)
+
+        # Assert
+        assert result == original_config
+        assert original_config == CHAT_APP_COMPLETION_PROMPT_CONFIG
+
+    def test_get_common_prompt_should_return_empty_dict_when_app_mode_invalid(self) -> None:
+        """Test invalid app mode returns empty dict."""
+        # Arrange
+        app_mode = "invalid"
+        model_mode = "chat"
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(app_mode, model_mode, "true")
+
+        # Assert
+        assert result == {}
+
+    def test_get_common_prompt_should_prepend_context_for_completion_prompt(self) -> None:
+        """Test context is prepended for completion prompt when has_context is true."""
+        # Arrange
+        original_config = copy.deepcopy(CHAT_APP_COMPLETION_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(AppMode.CHAT, "completion", "true")
+
+        # Assert
+        assert result["completion_prompt_config"]["prompt"]["text"].startswith(CONTEXT)
+        assert original_config == CHAT_APP_COMPLETION_PROMPT_CONFIG
+
+    def test_get_common_prompt_should_prepend_context_for_chat_prompt(self) -> None:
+        """Test context is prepended for chat prompt when has_context is true."""
+        # Arrange
+        original_config = copy.deepcopy(COMPLETION_APP_CHAT_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(AppMode.COMPLETION, "chat", "true")
+
+        # Assert
+        assert result["chat_prompt_config"]["prompt"][0]["text"].startswith(CONTEXT)
+        assert original_config == COMPLETION_APP_CHAT_PROMPT_CONFIG
+
+    def test_get_common_prompt_should_return_chat_prompt_without_context_when_has_context_false(self) -> None:
+        """Test chat prompt remains unchanged when has_context is false."""
+        # Arrange
+        original_config = copy.deepcopy(CHAT_APP_CHAT_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(AppMode.CHAT, "chat", "false")
+
+        # Assert
+        assert result == original_config
+        assert original_config == CHAT_APP_CHAT_PROMPT_CONFIG
+
+    def test_get_common_prompt_should_return_completion_prompt_for_completion_app_mode(self) -> None:
+        """Test completion app mode with completion model returns completion prompt."""
+        # Arrange
+        original_config = copy.deepcopy(COMPLETION_APP_COMPLETION_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(AppMode.COMPLETION, "completion", "false")
+
+        # Assert
+        assert result == original_config
+        assert original_config == COMPLETION_APP_COMPLETION_PROMPT_CONFIG
+
+    def test_get_common_prompt_should_return_empty_dict_when_model_mode_invalid(self) -> None:
+        """Test invalid model mode returns empty dict."""
+        # Arrange
+        app_mode = AppMode.CHAT
+        model_mode = "invalid"
+
+        # Act
+        result = AdvancedPromptTemplateService.get_common_prompt(app_mode, model_mode, "false")
+
+        # Assert
+        assert result == {}
+
+    def test_get_completion_prompt_should_not_prepend_context_when_has_context_false(self) -> None:
+        """Test helper keeps completion prompt unchanged when context is disabled."""
+        # Arrange
+        prompt_template = copy.deepcopy(CHAT_APP_COMPLETION_PROMPT_CONFIG)
+        original_text = prompt_template["completion_prompt_config"]["prompt"]["text"]
+
+        # Act
+        result = AdvancedPromptTemplateService.get_completion_prompt(prompt_template, "false", CONTEXT)
+
+        # Assert
+        assert result["completion_prompt_config"]["prompt"]["text"] == original_text
+
+    def test_get_chat_prompt_should_not_prepend_context_when_has_context_false(self) -> None:
+        """Test helper keeps chat prompt unchanged when context is disabled."""
+        # Arrange
+        prompt_template = copy.deepcopy(CHAT_APP_CHAT_PROMPT_CONFIG)
+        original_text = prompt_template["chat_prompt_config"]["prompt"][0]["text"]
+
+        # Act
+        result = AdvancedPromptTemplateService.get_chat_prompt(prompt_template, "false", CONTEXT)
+
+        # Assert
+        assert result["chat_prompt_config"]["prompt"][0]["text"] == original_text
+
+    def test_get_baichuan_prompt_should_return_chat_completion_config_when_chat_completion(self) -> None:
+        """Test baichuan chat/completion returns the expected config."""
+        # Arrange
+        original_config = copy.deepcopy(BAICHUAN_CHAT_APP_COMPLETION_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_baichuan_prompt(AppMode.CHAT, "completion", "false")
+
+        # Assert
+        assert result == original_config
+        assert original_config == BAICHUAN_CHAT_APP_COMPLETION_PROMPT_CONFIG
+
+    def test_get_baichuan_prompt_should_return_completion_chat_config_when_completion_chat(self) -> None:
+        """Test baichuan completion/chat returns the expected config."""
+        # Arrange
+        original_config = copy.deepcopy(BAICHUAN_COMPLETION_APP_CHAT_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_baichuan_prompt(AppMode.COMPLETION, "chat", "false")
+
+        # Assert
+        assert result == original_config
+        assert original_config == BAICHUAN_COMPLETION_APP_CHAT_PROMPT_CONFIG
+
+    def test_get_baichuan_prompt_should_return_completion_completion_config_when_enabled_context(self) -> None:
+        """Test baichuan completion/completion prepends baichuan context when enabled."""
+        # Arrange
+        original_config = copy.deepcopy(BAICHUAN_COMPLETION_APP_COMPLETION_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_baichuan_prompt(AppMode.COMPLETION, "completion", "true")
+
+        # Assert
+        assert result["completion_prompt_config"]["prompt"]["text"].startswith(BAICHUAN_CONTEXT)
+        assert original_config == BAICHUAN_COMPLETION_APP_COMPLETION_PROMPT_CONFIG
+
+    def test_get_baichuan_prompt_should_return_chat_chat_config_when_enabled_context(self) -> None:
+        """Test baichuan chat/chat prepends baichuan context when enabled."""
+        # Arrange
+        original_config = copy.deepcopy(BAICHUAN_CHAT_APP_CHAT_PROMPT_CONFIG)
+
+        # Act
+        result = AdvancedPromptTemplateService.get_baichuan_prompt(AppMode.CHAT, "chat", "true")
+
+        # Assert
+        assert result["chat_prompt_config"]["prompt"][0]["text"].startswith(BAICHUAN_CONTEXT)
+        assert original_config == BAICHUAN_CHAT_APP_CHAT_PROMPT_CONFIG
+
+    def test_get_baichuan_prompt_should_return_empty_dict_when_invalid_inputs(self) -> None:
+        """Test invalid baichuan mode combinations return empty dict."""
+        # Arrange
+        app_mode = "invalid"
+        model_mode = "invalid"
+
+        # Act
+        result = AdvancedPromptTemplateService.get_baichuan_prompt(app_mode, model_mode, "true")
+
+        # Assert
+        assert result == {}

api/tests/unit_tests/services/test_agent_service.py

@@ -0,0 +1,346 @@
+"""
+Unit tests for services.agent_service
+"""
+
+from collections.abc import Callable
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+import pytz
+
+from core.plugin.impl.exc import PluginDaemonClientSideError
+from models import Account
+from models.model import App, Conversation, EndUser, Message, MessageAgentThought
+from services.agent_service import AgentService
+
+
+def _make_current_user_account(timezone: str = "UTC") -> Account:
+    account = Account(name="Test User", email="test@example.com")
+    account.timezone = timezone
+    return account
+
+
+def _make_app_model(app_model_config: MagicMock | None) -> MagicMock:
+    app_model = MagicMock(spec=App)
+    app_model.id = "app-123"
+    app_model.tenant_id = "tenant-123"
+    app_model.app_model_config = app_model_config
+    return app_model
+
+
+def _make_conversation(from_end_user_id: str | None, from_account_id: str | None) -> MagicMock:
+    conversation = MagicMock(spec=Conversation)
+    conversation.id = "conv-123"
+    conversation.app_id = "app-123"
+    conversation.from_end_user_id = from_end_user_id
+    conversation.from_account_id = from_account_id
+    return conversation
+
+
+def _make_message(agent_thoughts: list[MessageAgentThought]) -> MagicMock:
+    message = MagicMock(spec=Message)
+    message.id = "msg-123"
+    message.conversation_id = "conv-123"
+    message.created_at = datetime(2024, 1, 1, tzinfo=pytz.UTC)
+    message.provider_response_latency = 1.23
+    message.answer_tokens = 4
+    message.message_tokens = 6
+    message.agent_thoughts = agent_thoughts
+    message.message_files = ["file-a.txt"]
+    return message
+
+
+def _make_agent_thought() -> MagicMock:
+    agent_thought = MagicMock(spec=MessageAgentThought)
+    agent_thought.tokens = 3
+    agent_thought.tool_input = "raw-input"
+    agent_thought.observation = "raw-output"
+    agent_thought.thought = "thinking"
+    agent_thought.created_at = datetime(2024, 1, 1, tzinfo=pytz.UTC)
+    agent_thought.files = []
+    agent_thought.tools = ["tool_a", "dataset_tool"]
+    agent_thought.tool_labels = {"tool_a": "Tool A"}
+    agent_thought.tool_meta = {
+        "tool_a": {
+            "tool_config": {
+                "tool_provider_type": "custom",
+                "tool_provider": "provider-1",
+            },
+            "tool_parameters": {"param": "value"},
+            "time_cost": 2.5,
+        },
+        "dataset_tool": {
+            "tool_config": {
+                "tool_provider_type": "dataset-retrieval",
+                "tool_provider": "dataset-provider",
+            }
+        },
+    }
+    agent_thought.tool_inputs_dict = {"tool_a": {"q": "hello"}, "dataset_tool": {"k": "v"}}
+    agent_thought.tool_outputs_dict = {"tool_a": {"result": "ok"}}
+    return agent_thought
+
+
+def _build_query_side_effect(
+    conversation: Conversation | None,
+    message: Message | None,
+    executor: EndUser | Account | None,
+) -> Callable[..., MagicMock]:
+    def _query_side_effect(*args: object, **kwargs: object) -> MagicMock:
+        query = MagicMock()
+        query.where.return_value = query
+        if any(arg is Conversation for arg in args):
+            query.first.return_value = conversation
+        elif any(arg is Message for arg in args):
+            query.first.return_value = message
+        elif any(arg is EndUser for arg in args) or any(arg is Account for arg in args):
+            query.first.return_value = executor
+        return query
+
+    return _query_side_effect
+
+
+class TestAgentServiceGetAgentLogs:
+    """Test suite for AgentService.get_agent_logs."""
+
+    def test_get_agent_logs_should_raise_when_conversation_missing(self) -> None:
+        """Test missing conversation raises ValueError."""
+        # Arrange
+        app_model = _make_app_model(MagicMock())
+        with patch("services.agent_service.db") as mock_db:
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = None
+            mock_db.session.query.return_value = query
+
+            # Act & Assert
+            with pytest.raises(ValueError):
+                AgentService.get_agent_logs(app_model, "missing-conv", "msg-1")
+
+    def test_get_agent_logs_should_raise_when_message_missing(self) -> None:
+        """Test missing message raises ValueError."""
+        # Arrange
+        app_model = _make_app_model(MagicMock())
+        conversation = _make_conversation(from_end_user_id="end-user-1", from_account_id=None)
+        with patch("services.agent_service.db") as mock_db:
+            conversation_query = MagicMock()
+            conversation_query.where.return_value = conversation_query
+            conversation_query.first.return_value = conversation
+
+            message_query = MagicMock()
+            message_query.where.return_value = message_query
+            message_query.first.return_value = None
+
+            mock_db.session.query.side_effect = [conversation_query, message_query]
+
+            # Act & Assert
+            with pytest.raises(ValueError):
+                AgentService.get_agent_logs(app_model, conversation.id, "missing-msg")
+
+    def test_get_agent_logs_should_raise_when_app_model_config_missing(self) -> None:
+        """Test missing app model config raises ValueError."""
+        # Arrange
+        app_model = _make_app_model(None)
+        conversation = _make_conversation(from_end_user_id="end-user-1", from_account_id=None)
+        message = _make_message([])
+        current_user = _make_current_user_account()
+
+        with patch("services.agent_service.db") as mock_db, patch("services.agent_service.current_user", current_user):
+            mock_db.session.query.side_effect = _build_query_side_effect(conversation, message, MagicMock())
+
+            # Act & Assert
+            with pytest.raises(ValueError):
+                AgentService.get_agent_logs(app_model, conversation.id, message.id)
+
+    def test_get_agent_logs_should_raise_when_agent_config_missing(self) -> None:
+        """Test missing agent config raises ValueError."""
+        # Arrange
+        app_model_config = MagicMock()
+        app_model_config.agent_mode_dict = {"strategy": "react"}
+        app_model_config.to_dict.return_value = {"tools": []}
+        app_model = _make_app_model(app_model_config)
+        conversation = _make_conversation(from_end_user_id="end-user-1", from_account_id=None)
+        message = _make_message([])
+        current_user = _make_current_user_account()
+
+        with (
+            patch("services.agent_service.db") as mock_db,
+            patch("services.agent_service.AgentConfigManager.convert", return_value=None),
+            patch("services.agent_service.current_user", current_user),
+        ):
+            mock_db.session.query.side_effect = _build_query_side_effect(conversation, message, MagicMock())
+
+            # Act & Assert
+            with pytest.raises(ValueError):
+                AgentService.get_agent_logs(app_model, conversation.id, message.id)
+
+    def test_get_agent_logs_should_return_logs_for_end_user_executor(self) -> None:
+        """Test agent logs returned for end-user executor with tool icons."""
+        # Arrange
+        agent_thought = _make_agent_thought()
+        message = _make_message([agent_thought])
+        conversation = _make_conversation(from_end_user_id="end-user-1", from_account_id=None)
+        executor = MagicMock(spec=EndUser)
+        executor.name = "End User"
+        app_model_config = MagicMock()
+        app_model_config.agent_mode_dict = {"strategy": "react"}
+        app_model_config.to_dict.return_value = {"tools": []}
+        app_model = _make_app_model(app_model_config)
+        current_user = _make_current_user_account()
+        agent_tool = MagicMock()
+        agent_tool.tool_name = "tool_a"
+        agent_tool.provider_type = "custom"
+        agent_tool.provider_id = "provider-2"
+        agent_config = MagicMock()
+        agent_config.tools = [agent_tool]
+
+        with (
+            patch("services.agent_service.db") as mock_db,
+            patch("services.agent_service.AgentConfigManager.convert", return_value=agent_config) as mock_convert,
+            patch("services.agent_service.ToolManager.get_tool_icon") as mock_get_icon,
+            patch("services.agent_service.current_user", current_user),
+        ):
+            mock_db.session.query.side_effect = _build_query_side_effect(conversation, message, executor)
+            mock_get_icon.side_effect = [None, "icon-a"]
+
+            # Act
+            result = AgentService.get_agent_logs(app_model, conversation.id, message.id)
+
+            # Assert
+            assert result["meta"]["status"] == "success"
+            assert result["meta"]["executor"] == "End User"
+            assert result["meta"]["total_tokens"] == 10
+            assert result["meta"]["agent_mode"] == "react"
+            assert result["meta"]["iterations"] == 1
+            assert result["files"] == ["file-a.txt"]
+            assert len(result["iterations"]) == 1
+            tool_calls = result["iterations"][0]["tool_calls"]
+            assert tool_calls[0]["tool_name"] == "tool_a"
+            assert tool_calls[0]["tool_icon"] == "icon-a"
+            assert tool_calls[1]["tool_name"] == "dataset_tool"
+            assert tool_calls[1]["tool_icon"] == ""
+            mock_convert.assert_called_once()
+
+    def test_get_agent_logs_should_return_account_executor_when_no_end_user(self) -> None:
+        """Test agent logs fall back to account executor when end user is missing."""
+        # Arrange
+        agent_thought = _make_agent_thought()
+        message = _make_message([agent_thought])
+        conversation = _make_conversation(from_end_user_id=None, from_account_id="account-1")
+        executor = MagicMock(spec=Account)
+        executor.name = "Account User"
+        app_model_config = MagicMock()
+        app_model_config.agent_mode_dict = {"strategy": "react"}
+        app_model_config.to_dict.return_value = {"tools": []}
+        app_model = _make_app_model(app_model_config)
+        current_user = _make_current_user_account()
+        agent_config = MagicMock()
+        agent_config.tools = []
+
+        with (
+            patch("services.agent_service.db") as mock_db,
+            patch("services.agent_service.AgentConfigManager.convert", return_value=agent_config),
+            patch("services.agent_service.ToolManager.get_tool_icon", return_value=""),
+            patch("services.agent_service.current_user", current_user),
+        ):
+            mock_db.session.query.side_effect = _build_query_side_effect(conversation, message, executor)
+
+            # Act
+            result = AgentService.get_agent_logs(app_model, conversation.id, message.id)
+
+            # Assert
+            assert result["meta"]["executor"] == "Account User"
+
+    def test_get_agent_logs_should_use_defaults_when_executor_and_tool_data_missing(self) -> None:
+        """Test unknown executor and missing tool details fall back to defaults."""
+        # Arrange
+        agent_thought = _make_agent_thought()
+        agent_thought.tool_labels = {}
+        agent_thought.tool_inputs_dict = {}
+        agent_thought.tool_outputs_dict = None
+        agent_thought.tool_meta = {"tool_a": {"error": "failed"}}
+        agent_thought.tools = ["tool_a"]
+
+        message = _make_message([agent_thought])
+        conversation = _make_conversation(from_end_user_id="end-user-1", from_account_id=None)
+        app_model_config = MagicMock()
+        app_model_config.agent_mode_dict = {}
+        app_model_config.to_dict.return_value = {"tools": []}
+        app_model = _make_app_model(app_model_config)
+        current_user = _make_current_user_account()
+        agent_config = MagicMock()
+        agent_config.tools = []
+
+        with (
+            patch("services.agent_service.db") as mock_db,
+            patch("services.agent_service.AgentConfigManager.convert", return_value=agent_config),
+            patch("services.agent_service.ToolManager.get_tool_icon", return_value=None),
+            patch("services.agent_service.current_user", current_user),
+        ):
+            mock_db.session.query.side_effect = _build_query_side_effect(conversation, message, None)
+
+            # Act
+            result = AgentService.get_agent_logs(app_model, conversation.id, message.id)
+
+            # Assert
+            assert result["meta"]["executor"] == "Unknown"
+            assert result["meta"]["agent_mode"] == "react"
+            tool_call = result["iterations"][0]["tool_calls"][0]
+            assert tool_call["status"] == "error"
+            assert tool_call["error"] == "failed"
+            assert tool_call["tool_label"] == "tool_a"
+            assert tool_call["tool_input"] == {}
+            assert tool_call["tool_output"] == {}
+            assert tool_call["time_cost"] == 0
+            assert tool_call["tool_parameters"] == {}
+            assert tool_call["tool_icon"] is None
+
+
+class TestAgentServiceProviders:
+    """Test suite for AgentService provider methods."""
+
+    def test_list_agent_providers_should_delegate_to_plugin_client(self) -> None:
+        """Test list_agent_providers delegates to PluginAgentClient."""
+        # Arrange
+        tenant_id = "tenant-1"
+        expected = [{"name": "provider"}]
+        with patch("services.agent_service.PluginAgentClient") as mock_client:
+            mock_client.return_value.fetch_agent_strategy_providers.return_value = expected
+
+            # Act
+            result = AgentService.list_agent_providers("user-1", tenant_id)
+
+            # Assert
+            assert result == expected
+            mock_client.return_value.fetch_agent_strategy_providers.assert_called_once_with(tenant_id)
+
+    def test_get_agent_provider_should_return_provider_when_successful(self) -> None:
+        """Test get_agent_provider returns provider when successful."""
+        # Arrange
+        tenant_id = "tenant-1"
+        provider_name = "provider-a"
+        expected = {"name": provider_name}
+        with patch("services.agent_service.PluginAgentClient") as mock_client:
+            mock_client.return_value.fetch_agent_strategy_provider.return_value = expected
+
+            # Act
+            result = AgentService.get_agent_provider("user-1", tenant_id, provider_name)
+
+            # Assert
+            assert result == expected
+            mock_client.return_value.fetch_agent_strategy_provider.assert_called_once_with(tenant_id, provider_name)
+
+    def test_get_agent_provider_should_raise_value_error_on_plugin_error(self) -> None:
+        """Test get_agent_provider wraps PluginDaemonClientSideError into ValueError."""
+        # Arrange
+        tenant_id = "tenant-1"
+        provider_name = "provider-a"
+        with patch("services.agent_service.PluginAgentClient") as mock_client:
+            mock_client.return_value.fetch_agent_strategy_provider.side_effect = PluginDaemonClientSideError(
+                "plugin error"
+            )
+
+            # Act & Assert
+            with pytest.raises(ValueError):
+                AgentService.get_agent_provider("user-1", tenant_id, provider_name)

api/tests/unit_tests/services/test_app_service.py

@@ -0,0 +1,609 @@
+"""Unit tests for services.app_service."""
+
+import json
+from types import SimpleNamespace
+from typing import cast
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from core.errors.error import ProviderTokenNotInitError
+from models import Account, Tenant
+from models.model import App, AppMode
+from services.app_service import AppService
+
+
+@pytest.fixture
+def service() -> AppService:
+    """Provide AppService instance."""
+    return AppService()
+
+
+@pytest.fixture
+def account() -> Account:
+    """Create account object for create_app tests."""
+    tenant = Tenant(name="Tenant")
+    tenant.id = "tenant-1"
+    result = Account(name="Account User", email="account@example.com")
+    result.id = "acc-1"
+    result._current_tenant = tenant
+    return result
+
+
+@pytest.fixture
+def default_args() -> dict:
+    """Create default create_app args."""
+    return {
+        "name": "Test App",
+        "mode": AppMode.CHAT.value,
+        "icon": "🤖",
+        "icon_background": "#FFFFFF",
+    }
+
+
+@pytest.fixture
+def app_template() -> dict:
+    """Create basic app template for create_app tests."""
+    return {
+        AppMode.CHAT: {
+            "app": {},
+            "model_config": {
+                "model": {
+                    "provider": "provider-a",
+                    "name": "model-a",
+                    "mode": "chat",
+                    "completion_params": {},
+                }
+            },
+        }
+    }
+
+
+def _make_current_user() -> Account:
+    user = Account(name="Tester", email="tester@example.com")
+    user.id = "user-1"
+    tenant = Tenant(name="Tenant")
+    tenant.id = "tenant-1"
+    user._current_tenant = tenant
+    return user
+
+
+class TestAppServicePagination:
+    """Test suite for get_paginate_apps."""
+
+    def test_get_paginate_apps_should_return_none_when_tag_filter_empty(self, service: AppService) -> None:
+        """Test pagination returns None when tag filter has no targets."""
+        # Arrange
+        args = {"mode": "chat", "page": 1, "limit": 20, "tag_ids": ["tag-1"]}
+
+        with patch("services.app_service.TagService.get_target_ids_by_tag_ids", return_value=[]):
+            # Act
+            result = service.get_paginate_apps("user-1", "tenant-1", args)
+
+            # Assert
+            assert result is None
+
+    def test_get_paginate_apps_should_delegate_to_db_paginate(self, service: AppService) -> None:
+        """Test pagination delegates to db.paginate when filters are valid."""
+        # Arrange
+        args = {
+            "mode": "workflow",
+            "is_created_by_me": True,
+            "name": "My_App%",
+            "tag_ids": ["tag-1"],
+            "page": 2,
+            "limit": 10,
+        }
+        expected_pagination = MagicMock()
+
+        with (
+            patch("services.app_service.TagService.get_target_ids_by_tag_ids", return_value=["app-1"]),
+            patch("libs.helper.escape_like_pattern", return_value="escaped"),
+            patch("services.app_service.db") as mock_db,
+        ):
+            mock_db.paginate.return_value = expected_pagination
+
+            # Act
+            result = service.get_paginate_apps("user-1", "tenant-1", args)
+
+            # Assert
+            assert result is expected_pagination
+            mock_db.paginate.assert_called_once()
+
+
+class TestAppServiceCreate:
+    """Test suite for create_app."""
+
+    def test_create_app_should_create_with_matching_default_model(
+        self,
+        service: AppService,
+        account: Account,
+        default_args: dict,
+        app_template: dict,
+    ) -> None:
+        """Test create_app uses matching default model and persists app config."""
+        # Arrange
+        app_instance = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+        app_model_config = SimpleNamespace(id="cfg-1")
+        model_instance = SimpleNamespace(
+            model_name="model-a",
+            provider="provider-a",
+            model_type_instance=MagicMock(),
+            credentials={"k": "v"},
+        )
+
+        with (
+            patch("services.app_service.default_app_templates", app_template),
+            patch("services.app_service.App", return_value=app_instance),
+            patch("services.app_service.AppModelConfig", return_value=app_model_config),
+            patch("services.app_service.ModelManager") as mock_model_manager,
+            patch("services.app_service.db") as mock_db,
+            patch("services.app_service.app_was_created") as mock_event,
+            patch("services.app_service.FeatureService.get_system_features") as mock_features,
+            patch("services.app_service.BillingService") as mock_billing,
+            patch("services.app_service.dify_config") as mock_config,
+        ):
+            manager = mock_model_manager.return_value
+            manager.get_default_model_instance.return_value = model_instance
+            mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=False))
+            mock_config.BILLING_ENABLED = True
+
+            # Act
+            result = service.create_app("tenant-1", default_args, account)
+
+            # Assert
+            assert result is app_instance
+            assert app_instance.app_model_config_id == "cfg-1"
+            mock_db.session.add.assert_any_call(app_instance)
+            mock_db.session.add.assert_any_call(app_model_config)
+            assert mock_db.session.flush.call_count == 2
+            mock_db.session.commit.assert_called_once()
+            mock_event.send.assert_called_once_with(app_instance, account=account)
+            mock_billing.clean_billing_info_cache.assert_called_once_with("tenant-1")
+
+    def test_create_app_should_raise_when_model_schema_missing(
+        self,
+        service: AppService,
+        account: Account,
+        default_args: dict,
+        app_template: dict,
+    ) -> None:
+        """Test create_app raises ValueError when non-matching model has no schema."""
+        # Arrange
+        app_instance = SimpleNamespace(id="app-1")
+        model_instance = SimpleNamespace(
+            model_name="model-b",
+            provider="provider-b",
+            model_type_instance=MagicMock(),
+            credentials={"k": "v"},
+        )
+        model_instance.model_type_instance.get_model_schema.return_value = None
+
+        with (
+            patch("services.app_service.default_app_templates", app_template),
+            patch("services.app_service.App", return_value=app_instance),
+            patch("services.app_service.ModelManager") as mock_model_manager,
+            patch("services.app_service.db") as mock_db,
+        ):
+            manager = mock_model_manager.return_value
+            manager.get_default_model_instance.return_value = model_instance
+
+            # Act & Assert
+            with pytest.raises(ValueError, match="model schema not found"):
+                service.create_app("tenant-1", default_args, account)
+            mock_db.session.commit.assert_not_called()
+
+    def test_create_app_should_fallback_to_default_provider_when_model_missing(
+        self,
+        service: AppService,
+        account: Account,
+        default_args: dict,
+        app_template: dict,
+    ) -> None:
+        """Test create_app falls back to provider/model name when no default model instance is available."""
+        # Arrange
+        app_instance = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+        app_model_config = SimpleNamespace(id="cfg-1")
+
+        with (
+            patch("services.app_service.default_app_templates", app_template),
+            patch("services.app_service.App", return_value=app_instance),
+            patch("services.app_service.AppModelConfig", return_value=app_model_config),
+            patch("services.app_service.ModelManager") as mock_model_manager,
+            patch("services.app_service.db") as mock_db,
+            patch("services.app_service.app_was_created") as mock_event,
+            patch("services.app_service.FeatureService.get_system_features") as mock_features,
+            patch("services.app_service.EnterpriseService") as mock_enterprise,
+            patch("services.app_service.dify_config") as mock_config,
+        ):
+            manager = mock_model_manager.return_value
+            manager.get_default_model_instance.side_effect = ProviderTokenNotInitError("not ready")
+            manager.get_default_provider_model_name.return_value = ("fallback-provider", "fallback-model")
+            mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=True))
+            mock_config.BILLING_ENABLED = False
+
+            # Act
+            result = service.create_app("tenant-1", default_args, account)
+
+            # Assert
+            assert result is app_instance
+            mock_event.send.assert_called_once_with(app_instance, account=account)
+            mock_db.session.commit.assert_called_once()
+            mock_enterprise.WebAppAuth.update_app_access_mode.assert_called_once_with("app-1", "private")
+
+    def test_create_app_should_log_and_fallback_on_unexpected_model_error(
+        self,
+        service: AppService,
+        account: Account,
+        default_args: dict,
+        app_template: dict,
+    ) -> None:
+        """Test unexpected model manager errors are logged and fallback provider is used."""
+        # Arrange
+        app_instance = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+        app_model_config = SimpleNamespace(id="cfg-1")
+
+        with (
+            patch("services.app_service.default_app_templates", app_template),
+            patch("services.app_service.App", return_value=app_instance),
+            patch("services.app_service.AppModelConfig", return_value=app_model_config),
+            patch("services.app_service.ModelManager") as mock_model_manager,
+            patch("services.app_service.db"),
+            patch("services.app_service.app_was_created"),
+            patch(
+                "services.app_service.FeatureService.get_system_features",
+                return_value=SimpleNamespace(webapp_auth=SimpleNamespace(enabled=False)),
+            ),
+            patch("services.app_service.dify_config", new=SimpleNamespace(BILLING_ENABLED=False)),
+            patch("services.app_service.logger") as mock_logger,
+        ):
+            manager = mock_model_manager.return_value
+            manager.get_default_model_instance.side_effect = RuntimeError("boom")
+            manager.get_default_provider_model_name.return_value = ("fallback-provider", "fallback-model")
+
+            # Act
+            result = service.create_app("tenant-1", default_args, account)
+
+            # Assert
+            assert result is app_instance
+            mock_logger.exception.assert_called_once()
+
+
+class TestAppServiceGetAndUpdate:
+    """Test suite for app retrieval and update methods."""
+
+    def test_get_app_should_return_original_when_not_agent_app(self, service: AppService) -> None:
+        """Test get_app returns original app for non-agent modes."""
+        # Arrange
+        app = MagicMock()
+        app.mode = AppMode.CHAT
+        app.is_agent = False
+
+        with patch("services.app_service.current_user", _make_current_user()):
+            # Act
+            result = service.get_app(app)
+
+            # Assert
+            assert result is app
+
+    def test_get_app_should_return_original_when_model_config_missing(self, service: AppService) -> None:
+        """Test get_app returns app when agent mode has no model config."""
+        # Arrange
+        app = MagicMock()
+        app.id = "app-1"
+        app.mode = AppMode.AGENT_CHAT
+        app.is_agent = False
+        app.app_model_config = None
+
+        with patch("services.app_service.current_user", _make_current_user()):
+            # Act
+            result = service.get_app(app)
+
+            # Assert
+            assert result is app
+
+    def test_get_app_should_mask_tool_parameters_for_agent_tools(self, service: AppService) -> None:
+        """Test get_app decrypts and masks secret tool parameters."""
+        # Arrange
+        tool = {
+            "provider_type": "builtin",
+            "provider_id": "provider-1",
+            "tool_name": "tool-a",
+            "tool_parameters": {"secret": "encrypted"},
+            "extra": True,
+        }
+        model_config = MagicMock()
+        model_config.agent_mode_dict = {"tools": [tool, {"skip": True}]}
+
+        app = MagicMock()
+        app.id = "app-1"
+        app.mode = AppMode.AGENT_CHAT
+        app.is_agent = False
+        app.app_model_config = model_config
+
+        manager = MagicMock()
+        manager.decrypt_tool_parameters.return_value = {"secret": "decrypted"}
+        manager.mask_tool_parameters.return_value = {"secret": "***"}
+
+        with (
+            patch("services.app_service.current_user", _make_current_user()),
+            patch("services.app_service.ToolManager.get_agent_tool_runtime", return_value=MagicMock()),
+            patch("services.app_service.ToolParameterConfigurationManager", return_value=manager),
+        ):
+            # Act
+            result = service.get_app(app)
+
+            # Assert
+            assert result.app_model_config is model_config
+            assert tool["tool_parameters"] == {"secret": "***"}
+            assert json.loads(model_config.agent_mode)["tools"][0]["tool_parameters"] == {"secret": "***"}
+
+    def test_get_app_should_continue_when_tool_parameter_masking_fails(self, service: AppService) -> None:
+        """Test get_app logs and continues when masking fails."""
+        # Arrange
+        tool = {
+            "provider_type": "builtin",
+            "provider_id": "provider-1",
+            "tool_name": "tool-a",
+            "tool_parameters": {"secret": "encrypted"},
+            "extra": True,
+        }
+        model_config = MagicMock()
+        model_config.agent_mode_dict = {"tools": [tool]}
+
+        app = MagicMock()
+        app.id = "app-1"
+        app.mode = AppMode.AGENT_CHAT
+        app.is_agent = False
+        app.app_model_config = model_config
+
+        with (
+            patch("services.app_service.current_user", _make_current_user()),
+            patch("services.app_service.ToolManager.get_agent_tool_runtime", side_effect=RuntimeError("mask-failed")),
+            patch("services.app_service.logger") as mock_logger,
+        ):
+            # Act
+            result = service.get_app(app)
+
+            # Assert
+            assert result.app_model_config is model_config
+            mock_logger.exception.assert_called_once()
+
+    def test_update_methods_should_mutate_app_and_commit(self, service: AppService) -> None:
+        """Test update methods set fields and commit changes."""
+        # Arrange
+        app = cast(
+            App,
+            SimpleNamespace(
+                name="old",
+                description="old",
+                icon_type="emoji",
+                icon="a",
+                icon_background="#111",
+                enable_site=True,
+                enable_api=True,
+            ),
+        )
+        args = {
+            "name": "new",
+            "description": "new-desc",
+            "icon_type": "image",
+            "icon": "new-icon",
+            "icon_background": "#222",
+            "use_icon_as_answer_icon": True,
+            "max_active_requests": 5,
+        }
+        user = SimpleNamespace(id="user-1")
+
+        with (
+            patch("services.app_service.current_user", user),
+            patch("services.app_service.db") as mock_db,
+            patch("services.app_service.naive_utc_now", return_value="now"),
+        ):
+            # Act
+            updated = service.update_app(app, args)
+            renamed = service.update_app_name(app, "rename")
+            iconed = service.update_app_icon(app, "icon-2", "#333")
+            site_same = service.update_app_site_status(app, app.enable_site)
+            api_same = service.update_app_api_status(app, app.enable_api)
+            site_changed = service.update_app_site_status(app, False)
+            api_changed = service.update_app_api_status(app, False)
+
+            # Assert
+            assert updated is app
+            assert renamed is app
+            assert iconed is app
+            assert site_same is app
+            assert api_same is app
+            assert site_changed is app
+            assert api_changed is app
+            assert mock_db.session.commit.call_count >= 5
+
+
+class TestAppServiceDeleteAndMeta:
+    """Test suite for delete and metadata methods."""
+
+    def test_delete_app_should_cleanup_and_enqueue_task(self, service: AppService) -> None:
+        """Test delete_app removes app, runs cleanup, and triggers async deletion task."""
+        # Arrange
+        app = cast(App, SimpleNamespace(id="app-1", tenant_id="tenant-1"))
+
+        with (
+            patch("services.app_service.db") as mock_db,
+            patch(
+                "services.app_service.FeatureService.get_system_features",
+                return_value=SimpleNamespace(webapp_auth=SimpleNamespace(enabled=True)),
+            ),
+            patch("services.app_service.EnterpriseService") as mock_enterprise,
+            patch(
+                "services.app_service.dify_config",
+                new=SimpleNamespace(BILLING_ENABLED=True, CONSOLE_API_URL="https://console.example"),
+            ),
+            patch("services.app_service.BillingService") as mock_billing,
+            patch("services.app_service.remove_app_and_related_data_task") as mock_task,
+        ):
+            # Act
+            service.delete_app(app)
+
+            # Assert
+            mock_db.session.delete.assert_called_once_with(app)
+            mock_db.session.commit.assert_called_once()
+            mock_enterprise.WebAppAuth.cleanup_webapp.assert_called_once_with("app-1")
+            mock_billing.clean_billing_info_cache.assert_called_once_with("tenant-1")
+            mock_task.delay.assert_called_once_with(tenant_id="tenant-1", app_id="app-1")
+
+    def test_get_app_meta_should_handle_workflow_and_tool_provider_icons(self, service: AppService) -> None:
+        """Test get_app_meta extracts builtin and API tool icons from workflow graph."""
+        # Arrange
+        workflow = SimpleNamespace(
+            graph_dict={
+                "nodes": [
+                    {
+                        "data": {
+                            "type": "tool",
+                            "provider_type": "builtin",
+                            "provider_id": "builtin-provider",
+                            "tool_name": "tool_builtin",
+                        }
+                    },
+                    {
+                        "data": {
+                            "type": "tool",
+                            "provider_type": "api",
+                            "provider_id": "api-provider-id",
+                            "tool_name": "tool_api",
+                        }
+                    },
+                ]
+            }
+        )
+        app = cast(
+            App,
+            SimpleNamespace(
+                mode=AppMode.WORKFLOW.value,
+                workflow=workflow,
+                app_model_config=None,
+                tenant_id="tenant-1",
+                icon_type="emoji",
+                icon_background="#fff",
+            ),
+        )
+
+        provider = SimpleNamespace(icon=json.dumps({"background": "#000", "content": "A"}))
+
+        with (
+            patch("services.app_service.dify_config", new=SimpleNamespace(CONSOLE_API_URL="https://console.example")),
+            patch("services.app_service.db") as mock_db,
+        ):
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = provider
+            mock_db.session.query.return_value = query
+
+            # Act
+            meta = service.get_app_meta(app)
+
+            # Assert
+            assert meta["tool_icons"]["tool_builtin"].endswith("/builtin-provider/icon")
+            assert meta["tool_icons"]["tool_api"] == {"background": "#000", "content": "A"}
+
+    def test_get_app_meta_should_use_default_api_icon_on_lookup_error(self, service: AppService) -> None:
+        """Test get_app_meta falls back to default icon when API provider lookup fails."""
+        # Arrange
+        app_model_config = SimpleNamespace(
+            agent_mode_dict={
+                "tools": [{"provider_type": "api", "provider_id": "x", "tool_name": "t", "tool_parameters": {}}]
+            }
+        )
+        app = cast(App, SimpleNamespace(mode=AppMode.CHAT.value, app_model_config=app_model_config, workflow=None))
+
+        with (
+            patch("services.app_service.dify_config", new=SimpleNamespace(CONSOLE_API_URL="https://console.example")),
+            patch("services.app_service.db") as mock_db,
+        ):
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = None
+            mock_db.session.query.return_value = query
+
+            # Act
+            meta = service.get_app_meta(app)
+
+            # Assert
+            assert meta["tool_icons"]["t"] == {"background": "#252525", "content": "\ud83d\ude01"}
+
+    def test_get_app_meta_should_return_empty_when_required_data_missing(self, service: AppService) -> None:
+        """Test get_app_meta returns empty metadata when workflow/model config is absent."""
+        # Arrange
+        workflow_app = cast(App, SimpleNamespace(mode=AppMode.WORKFLOW.value, workflow=None))
+        chat_app = cast(App, SimpleNamespace(mode=AppMode.CHAT.value, app_model_config=None))
+
+        # Act
+        workflow_meta = service.get_app_meta(workflow_app)
+        chat_meta = service.get_app_meta(chat_app)
+
+        # Assert
+        assert workflow_meta == {"tool_icons": {}}
+        assert chat_meta == {"tool_icons": {}}
+
+
+class TestAppServiceCodeLookup:
+    """Test suite for app code lookup methods."""
+
+    def test_get_app_code_by_id_should_raise_when_site_missing(self) -> None:
+        """Test get_app_code_by_id raises when site is missing."""
+        # Arrange
+        with patch("services.app_service.db") as mock_db:
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = None
+            mock_db.session.query.return_value = query
+
+            # Act & Assert
+            with pytest.raises(ValueError, match="not found"):
+                AppService.get_app_code_by_id("app-1")
+
+    def test_get_app_code_by_id_should_return_code(self) -> None:
+        """Test get_app_code_by_id returns site code."""
+        # Arrange
+        site = SimpleNamespace(code="code-1")
+        with patch("services.app_service.db") as mock_db:
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = site
+            mock_db.session.query.return_value = query
+
+            # Act
+            result = AppService.get_app_code_by_id("app-1")
+
+            # Assert
+            assert result == "code-1"
+
+    def test_get_app_id_by_code_should_raise_when_site_missing(self) -> None:
+        """Test get_app_id_by_code raises when code does not exist."""
+        # Arrange
+        with patch("services.app_service.db") as mock_db:
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = None
+            mock_db.session.query.return_value = query
+
+            # Act & Assert
+            with pytest.raises(ValueError, match="not found"):
+                AppService.get_app_id_by_code("missing")
+
+    def test_get_app_id_by_code_should_return_app_id(self) -> None:
+        """Test get_app_id_by_code returns linked app id."""
+        # Arrange
+        site = SimpleNamespace(app_id="app-1")
+        with patch("services.app_service.db") as mock_db:
+            query = MagicMock()
+            query.where.return_value = query
+            query.first.return_value = site
+            mock_db.session.query.return_value = query
+
+            # Act
+            result = AppService.get_app_id_by_code("code-1")
+
+            # Assert
+            assert result == "app-1"

api/tests/unit_tests/services/test_batch_indexing_base.py

@@ -0,0 +1,387 @@
+from dataclasses import asdict
+from typing import Any, ClassVar, cast
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from core.entities.document_task import DocumentTask
+from enums.cloud_plan import CloudPlan
+from services.document_indexing_proxy.batch_indexing_base import BatchDocumentIndexingProxy
+
+# ---------------------------------------------------------------------------
+# Concrete subclass for testing (the base class is abstract)
+# ---------------------------------------------------------------------------
+
+
+class ConcreteBatchProxy(BatchDocumentIndexingProxy):
+    """Minimal concrete implementation that provides the required class-level vars."""
+
+    QUEUE_NAME: ClassVar[str] = "test_queue"
+    NORMAL_TASK_FUNC: ClassVar[Any] = MagicMock(name="NORMAL_TASK_FUNC")
+    PRIORITY_TASK_FUNC: ClassVar[Any] = MagicMock(name="PRIORITY_TASK_FUNC")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+TENANT_ID = "tenant-abc"
+DATASET_ID = "dataset-xyz"
+DOC_IDS: list[str] = ["doc-1", "doc-2", "doc-3"]
+
+
+def make_proxy(**kwargs: Any) -> ConcreteBatchProxy:
+    """Factory: returns a ConcreteBatchProxy with TenantIsolatedTaskQueue mocked out."""
+    with patch("services.document_indexing_proxy.batch_indexing_base.TenantIsolatedTaskQueue") as MockQueue:
+        proxy = ConcreteBatchProxy(
+            tenant_id=kwargs.get("tenant_id", TENANT_ID),
+            dataset_id=kwargs.get("dataset_id", DATASET_ID),
+            document_ids=kwargs.get("document_ids", DOC_IDS),
+        )
+        # Expose the mock queue on the proxy so tests can assert on it
+        proxy._tenant_isolated_task_queue = MockQueue.return_value
+    return proxy
+
+
+# ---------------------------------------------------------------------------
+# Test suite
+# ---------------------------------------------------------------------------
+
+
+class TestBatchDocumentIndexingProxyInit:
+    """Tests for __init__ of BatchDocumentIndexingProxy."""
+
+    def test_should_store_document_ids_when_initialized(self) -> None:
+        """Verify that document_ids are stored on the proxy instance."""
+        # Arrange
+        doc_ids: list[str] = ["doc-a", "doc-b"]
+
+        # Act
+        with patch("services.document_indexing_proxy.batch_indexing_base.TenantIsolatedTaskQueue"):
+            proxy = ConcreteBatchProxy(TENANT_ID, DATASET_ID, doc_ids)
+
+        # Assert
+        assert proxy._document_ids == doc_ids
+
+    def test_should_propagate_tenant_and_dataset_to_base_when_initialized(self) -> None:
+        """Verify that tenant_id and dataset_id are forwarded to the parent class."""
+        # Arrange / Act
+        with patch("services.document_indexing_proxy.batch_indexing_base.TenantIsolatedTaskQueue"):
+            proxy = ConcreteBatchProxy(TENANT_ID, DATASET_ID, DOC_IDS)
+
+        # Assert
+        assert proxy._tenant_id == TENANT_ID
+        assert proxy._dataset_id == DATASET_ID
+
+    def test_should_create_tenant_isolated_queue_with_correct_args_when_initialized(self) -> None:
+        """Verify that TenantIsolatedTaskQueue is constructed with (tenant_id, QUEUE_NAME)."""
+        # Arrange / Act
+        with patch("services.document_indexing_proxy.batch_indexing_base.TenantIsolatedTaskQueue") as MockQueue:
+            ConcreteBatchProxy(TENANT_ID, DATASET_ID, DOC_IDS)
+
+        # Assert
+        MockQueue.assert_called_once_with(TENANT_ID, ConcreteBatchProxy.QUEUE_NAME)
+
+    @pytest.mark.parametrize("doc_ids", [[], ["single-doc"], ["d1", "d2", "d3", "d4"]])
+    def test_should_accept_any_length_document_ids_when_initialized(self, doc_ids: list[str]) -> None:
+        """Verify that empty, single, and multiple document IDs are all accepted."""
+        # Arrange / Act
+        with patch("services.document_indexing_proxy.batch_indexing_base.TenantIsolatedTaskQueue"):
+            proxy = ConcreteBatchProxy(TENANT_ID, DATASET_ID, doc_ids)
+
+        # Assert
+        assert list(proxy._document_ids) == doc_ids
+
+
+class TestSendToDirectQueue:
+    """Tests for _send_to_direct_queue."""
+
+    def test_should_call_task_func_delay_with_correct_args_when_sent_to_direct_queue(
+        self,
+    ) -> None:
+        """Verify that task_func.delay is called with the right kwargs."""
+        # Arrange
+        proxy = make_proxy()
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_direct_queue(task_func)
+
+        # Assert
+        task_func.delay.assert_called_once_with(
+            tenant_id=TENANT_ID,
+            dataset_id=DATASET_ID,
+            document_ids=DOC_IDS,
+        )
+
+    def test_should_not_interact_with_tenant_queue_when_sent_to_direct_queue(self) -> None:
+        """Direct queue path must never touch the tenant-isolated queue."""
+        # Arrange
+        proxy = make_proxy()
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_direct_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        mock_queue.push_tasks.assert_not_called()
+        mock_queue.set_task_waiting_time.assert_not_called()
+
+    def test_should_forward_any_callable_when_sent_to_direct_queue(self) -> None:
+        """Verify that different task functions are each called correctly."""
+        # Arrange
+        proxy = make_proxy()
+        task_a, task_b = MagicMock(), MagicMock()
+
+        # Act
+        proxy._send_to_direct_queue(task_a)
+        proxy._send_to_direct_queue(task_b)
+
+        # Assert
+        task_a.delay.assert_called_once()
+        task_b.delay.assert_called_once()
+
+
+class TestSendToTenantQueue:
+    """Tests for _send_to_tenant_queue — both branches."""
+
+    # ------------------------------------------------------------------
+    # Branch 1: get_task_key() is truthy → push to waiting queue
+    # ------------------------------------------------------------------
+
+    def test_should_push_task_to_queue_when_task_key_exists(self) -> None:
+        """When get_task_key() is truthy, tasks must be pushed via push_tasks()."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = "existing-key"
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        expected_payload = [asdict(DocumentTask(tenant_id=TENANT_ID, dataset_id=DATASET_ID, document_ids=DOC_IDS))]
+        mock_queue.push_tasks.assert_called_once_with(expected_payload)
+
+    def test_should_not_call_task_func_delay_when_task_key_exists(self) -> None:
+        """When a key already exists, task_func.delay must never be called."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = "existing-key"
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        cast(MagicMock, task_func.delay).assert_not_called()
+
+    def test_should_not_set_waiting_time_when_task_key_exists(self) -> None:
+        """When a key already exists, set_task_waiting_time must never be called."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = "existing-key"
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        mock_queue.set_task_waiting_time.assert_not_called()
+
+    def test_should_serialize_document_task_correctly_when_pushing_to_queue(self) -> None:
+        """Verify the serialised payload matches asdict(DocumentTask(...))."""
+        # Arrange
+        proxy = make_proxy(document_ids=["doc-x"])
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = "k"
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert — inspect the payload passed to push_tasks
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        call_args = mock_queue.push_tasks.call_args
+        pushed_list = call_args[0][0]  # first positional arg
+        assert len(pushed_list) == 1
+        assert pushed_list[0]["tenant_id"] == TENANT_ID
+        assert pushed_list[0]["dataset_id"] == DATASET_ID
+        assert pushed_list[0]["document_ids"] == ["doc-x"]
+
+    # ------------------------------------------------------------------
+    # Branch 2: get_task_key() is falsy → set flag + dispatch via delay
+    # ------------------------------------------------------------------
+
+    def test_should_set_waiting_time_and_call_delay_when_no_task_key(self) -> None:
+        """When get_task_key() is falsy, set_task_waiting_time and task_func.delay are invoked."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = None
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        mock_queue.set_task_waiting_time.assert_called_once()
+        cast(MagicMock, task_func.delay).assert_called_once_with(
+            tenant_id=TENANT_ID,
+            dataset_id=DATASET_ID,
+            document_ids=DOC_IDS,
+        )
+
+    def test_should_not_push_tasks_when_no_task_key(self) -> None:
+        """When get_task_key() is falsy, push_tasks must never be called."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = None
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        mock_queue.push_tasks.assert_not_called()
+
+    @pytest.mark.parametrize("falsy_key", [None, "", 0, False])
+    def test_should_init_task_when_key_is_any_falsy_value(self, falsy_key: Any) -> None:
+        """Verify that any falsy return from get_task_key() triggers the init branch."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = falsy_key
+        task_func = MagicMock()
+
+        # Act
+        proxy._send_to_tenant_queue(task_func)
+
+        # Assert
+        mock_queue = cast(MagicMock, proxy._tenant_isolated_task_queue)
+        mock_queue.set_task_waiting_time.assert_called_once()
+        cast(MagicMock, task_func.delay).assert_called_once()
+
+
+class TestDispatchRouting:
+    """Tests for the _dispatch / delay routing logic inherited from the base class."""
+
+    def _mock_features(self, enabled: bool, plan: CloudPlan) -> MagicMock:
+        features = MagicMock()
+        features.billing.enabled = enabled
+        features.billing.subscription.plan = plan
+        return features
+
+    def test_should_send_to_normal_tenant_queue_when_billing_enabled_and_sandbox_plan(self) -> None:
+        """Sandbox plan routes to normal priority queue with tenant isolation."""
+        # Arrange
+        proxy = make_proxy()
+        proxy._tenant_isolated_task_queue.get_task_key.return_value = None
+
+        with patch("services.document_indexing_proxy.base.FeatureService.get_features") as mock_features:
+            mock_features.return_value = self._mock_features(enabled=True, plan=CloudPlan.SANDBOX)
+
+            # Act
+            with patch.object(proxy, "_send_to_default_tenant_queue") as mock_method:
+                proxy._dispatch()
+
+        # Assert
+        mock_method.assert_called_once()
+
+    def test_should_send_to_priority_tenant_queue_when_billing_enabled_and_paid_plan(self) -> None:
+        """Non-sandbox paid plan routes to priority queue with tenant isolation."""
+        # Arrange
+        proxy = make_proxy()
+
+        with patch("services.document_indexing_proxy.base.FeatureService.get_features") as mock_features:
+            mock_features.return_value = self._mock_features(enabled=True, plan=CloudPlan.PROFESSIONAL)
+
+            # Act
+            with patch.object(proxy, "_send_to_priority_tenant_queue") as mock_method:
+                proxy._dispatch()
+
+        # Assert
+        mock_method.assert_called_once()
+
+    def test_should_send_to_priority_direct_queue_when_billing_not_enabled(self) -> None:
+        """Self-hosted / no billing → priority direct queue (no tenant isolation)."""
+        # Arrange
+        proxy = make_proxy()
+
+        with patch("services.document_indexing_proxy.base.FeatureService.get_features") as mock_features:
+            mock_features.return_value = self._mock_features(enabled=False, plan=CloudPlan.SANDBOX)
+
+            # Act
+            with patch.object(proxy, "_send_to_priority_direct_queue") as mock_method:
+                proxy._dispatch()
+
+        # Assert
+        mock_method.assert_called_once()
+
+    def test_should_call_dispatch_when_delay_is_invoked(self) -> None:
+        """Calling delay() must invoke _dispatch() exactly once."""
+        # Arrange
+        proxy = make_proxy()
+
+        # Act
+        with patch.object(proxy, "_dispatch") as mock_dispatch:
+            proxy.delay()
+
+        # Assert
+        mock_dispatch.assert_called_once()
+
+    def test_should_use_feature_service_for_billing_info(self) -> None:
+        """Verify that FeatureService.get_features is consulted during dispatch."""
+        # Arrange
+        proxy = make_proxy()
+
+        with patch("services.document_indexing_proxy.base.FeatureService.get_features") as mock_features:
+            mock_features.return_value = self._mock_features(enabled=False, plan=CloudPlan.SANDBOX)
+            with patch.object(proxy, "_send_to_priority_direct_queue"):
+                # Act
+                proxy._dispatch()
+
+        # Assert
+        mock_features.assert_called_once_with(TENANT_ID)
+
+
+class TestBaseRouterHelpers:
+    """Tests for the three routing helper methods from the base class."""
+
+    def test_should_call_send_to_tenant_queue_with_normal_func_when_default_tenant_queue(self) -> None:
+        """_send_to_default_tenant_queue must forward NORMAL_TASK_FUNC."""
+        # Arrange
+        proxy = make_proxy()
+
+        # Act
+        with patch.object(proxy, "_send_to_tenant_queue") as mock_method:
+            proxy._send_to_default_tenant_queue()
+
+        # Assert
+        mock_method.assert_called_once_with(ConcreteBatchProxy.NORMAL_TASK_FUNC)
+
+    def test_should_call_send_to_tenant_queue_with_priority_func_when_priority_tenant_queue(self) -> None:
+        """_send_to_priority_tenant_queue must forward PRIORITY_TASK_FUNC."""
+        # Arrange
+        proxy = make_proxy()
+
+        # Act
+        with patch.object(proxy, "_send_to_tenant_queue") as mock_method:
+            proxy._send_to_priority_tenant_queue()
+
+        # Assert
+        mock_method.assert_called_once_with(ConcreteBatchProxy.PRIORITY_TASK_FUNC)
+
+    def test_should_call_send_to_direct_queue_with_priority_func_when_priority_direct_queue(self) -> None:
+        """_send_to_priority_direct_queue must forward PRIORITY_TASK_FUNC."""
+        # Arrange
+        proxy = make_proxy()
+
+        # Act
+        with patch.object(proxy, "_send_to_direct_queue") as mock_method:
+            proxy._send_to_priority_direct_queue()
+
+        # Assert
+        mock_method.assert_called_once_with(ConcreteBatchProxy.PRIORITY_TASK_FUNC)

api/tests/unit_tests/services/test_conversation_variable_updater.py

@@ -3,7 +3,7 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from core.variables.variables import StringVariable
+from dify_graph.variables import StringVariable
 from services.conversation_variable_updater import ConversationVariableNotFoundError, ConversationVariableUpdater
 
 

api/tests/unit_tests/services/test_datasource_provider_service.py

@@ -0,0 +1,760 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from sqlalchemy.orm import Session
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from dify_graph.model_runtime.entities.provider_entities import FormType
+from models.account import Account
+from models.model import EndUser
+from models.oauth import DatasourceProvider
+from models.provider_ids import DatasourceProviderID
+from services.datasource_provider_service import DatasourceProviderService, get_current_user
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def make_id(s: str = "org/plugin/provider") -> DatasourceProviderID:
+    return DatasourceProviderID(s)
+
+
+# ---------------------------------------------------------------------------
+# Test class
+# ---------------------------------------------------------------------------
+
+
+class TestDatasourceProviderService:
+    """Comprehensive tests for DatasourceProviderService targeting >95% coverage."""
+
+    @pytest.fixture
+    def service(self):
+        return DatasourceProviderService()
+
+    @pytest.fixture
+    def mock_db_session(self):
+        """
+        Robust, chainable query mock.
+        q returns itself for .filter_by(), .order_by(), .where() so any
+        SQLAlchemy chaining pattern works without multiple brittle sub-mocks.
+        """
+        with patch("services.datasource_provider_service.Session") as mock_cls:
+            sess = MagicMock(spec=Session)
+
+            q = MagicMock()
+            sess.query.return_value = q
+
+            # Self-returning chain — any method called on q returns q
+            q.filter_by.return_value = q
+            q.order_by.return_value = q
+            q.where.return_value = q
+
+            # Default terminal values (tests override per-case)
+            q.first.return_value = None
+            q.all.return_value = []
+            q.count.return_value = 0
+            q.delete.return_value = 1
+
+            mock_cls.return_value.__enter__.return_value = sess
+            mock_cls.return_value.no_autoflush.__enter__.return_value = sess
+
+            yield sess
+
+    @pytest.fixture(autouse=True)
+    def patch_db(self, mock_db_session):
+        with patch("services.datasource_provider_service.db") as mock_db:
+            mock_db.session = mock_db_session
+            mock_db.engine = MagicMock()
+            yield mock_db
+
+    @pytest.fixture(autouse=True)
+    def patch_externals(self):
+        with (
+            patch("httpx.request") as mock_httpx,
+            patch("services.datasource_provider_service.dify_config") as mock_cfg,
+            patch("services.datasource_provider_service.encrypter") as mock_enc,
+            patch("services.datasource_provider_service.redis_client") as mock_redis,
+            patch("services.datasource_provider_service.generate_incremental_name") as mock_genname,
+            patch("services.datasource_provider_service.OAuthHandler") as mock_oauth,
+        ):
+            mock_cfg.CONSOLE_API_URL = "http://localhost"
+            mock_enc.encrypt_token.return_value = "enc_tok"
+            mock_enc.decrypt_token.return_value = "dec_tok"
+            mock_enc.decrypt.return_value = {"k": "dec"}
+            mock_enc.encrypt.return_value = {"k": "enc"}
+            mock_enc.obfuscated_token.return_value = "obf"
+            mock_enc.mask_plugin_credentials.return_value = {"k": "mask"}
+
+            mock_redis.lock.return_value.__enter__.return_value = MagicMock()
+            mock_genname.return_value = "gen_name"
+
+            mock_oauth.return_value.refresh_credentials.return_value = MagicMock(
+                credentials={"k": "v"}, expires_at=9999
+            )
+
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.json.return_value = {
+                "code": 0,
+                "message": "ok",
+                "data": {
+                    "provider": "prov",
+                    "plugin_unique_identifier": "pui",
+                    "plugin_id": "org/plug",
+                    "is_authorized": False,
+                    "declaration": {
+                        "identity": {
+                            "author": "a",
+                            "name": "n",
+                            "description": {"en_US": "d"},
+                            "icon": "i",
+                            "label": {"en_US": "l"},
+                        },
+                        "credentials_schema": [],
+                        "oauth_schema": {"credentials_schema": [], "client_schema": []},
+                        "provider_type": "local_file",
+                        "datasources": [],
+                    },
+                },
+            }
+            mock_httpx.return_value = resp
+
+            # Store handles for assertions
+            self._enc = mock_enc
+            self._redis = mock_redis
+            yield
+
+    @pytest.fixture
+    def mock_user(self):
+        u = MagicMock()
+        u.id = "uid-1"
+        return u
+
+    # -----------------------------------------------------------------------
+    # get_current_user (lines 27-40)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_proxy_when_current_object_is_account(self):
+        with patch("libs.login.current_user", new_callable=MagicMock) as proxy:
+            user_obj = MagicMock()
+            user_obj.__class__ = Account
+            proxy._get_current_object.return_value = user_obj
+            assert get_current_user() is proxy
+
+    def test_should_return_proxy_when_current_object_is_enduser(self):
+        with patch("libs.login.current_user", new_callable=MagicMock) as proxy:
+            user_obj = MagicMock()
+            user_obj.__class__ = EndUser
+            proxy._get_current_object.return_value = user_obj
+            assert get_current_user() is proxy
+
+    def test_should_return_proxy_when_get_current_object_raises_attribute_error(self):
+        """AttributeError from LocalProxy falls back to the proxy itself."""
+        with patch("libs.login.current_user", new_callable=MagicMock) as proxy:
+            proxy._get_current_object.side_effect = AttributeError("no attr")
+            proxy.__class__ = Account  # make the proxy itself satisfy isinstance
+            assert get_current_user() is proxy
+
+    def test_should_raise_type_error_when_user_is_not_account_or_enduser(self):
+        with patch("libs.login.current_user", new_callable=MagicMock) as proxy:
+            proxy._get_current_object.return_value = "plain_string"
+            with pytest.raises(TypeError, match="current_user must be Account or EndUser"):
+                get_current_user()
+
+    # -----------------------------------------------------------------------
+    # is_system_oauth_params_exist (line 357-363)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_true_when_system_oauth_params_exist(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = MagicMock()
+        assert service.is_system_oauth_params_exist(make_id()) is True
+
+    def test_should_return_false_when_system_oauth_params_missing(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        assert service.is_system_oauth_params_exist(make_id()) is False
+
+    # -----------------------------------------------------------------------
+    # is_tenant_oauth_params_enabled (lines 365-379)
+    # NOTE: uses .count() not .first()
+    # -----------------------------------------------------------------------
+
+    def test_should_return_true_when_tenant_oauth_params_enabled(self, service, mock_db_session):
+        mock_db_session.query().count.return_value = 1
+        assert service.is_tenant_oauth_params_enabled("t1", make_id()) is True
+
+    def test_should_return_false_when_tenant_oauth_params_disabled(self, service, mock_db_session):
+        mock_db_session.query().count.return_value = 0
+        assert service.is_tenant_oauth_params_enabled("t1", make_id()) is False
+
+    # -----------------------------------------------------------------------
+    # remove_oauth_custom_client_params (lines 55-61)
+    # -----------------------------------------------------------------------
+
+    def test_should_delete_tenant_config_when_removing_oauth_params(self, service, mock_db_session):
+        service.remove_oauth_custom_client_params("t1", make_id())
+        mock_db_session.query().delete.assert_called_once()
+
+    # -----------------------------------------------------------------------
+    # setup_oauth_custom_client_params (315-351)
+    # -----------------------------------------------------------------------
+
+    def test_should_skip_db_write_when_credentials_are_none(self, service, mock_db_session):
+        """When credentials=None, should return immediately without any DB write."""
+        service.setup_oauth_custom_client_params("t1", make_id(), None, None)
+        mock_db_session.add.assert_not_called()
+
+    def test_should_create_new_config_when_none_exists(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        with patch.object(service, "get_oauth_encrypter", return_value=(self._enc, None)):
+            service.setup_oauth_custom_client_params("t1", make_id(), {"k": "v"}, True)
+        mock_db_session.add.assert_called_once()
+
+    def test_should_update_existing_config_when_record_found(self, service, mock_db_session):
+        existing = MagicMock()
+        mock_db_session.query().first.return_value = existing
+        with patch.object(service, "get_oauth_encrypter", return_value=(self._enc, None)):
+            service.setup_oauth_custom_client_params("t1", make_id(), {"k": "v"}, False)
+        mock_db_session.add.assert_not_called()  # update in place, no add
+
+    # -----------------------------------------------------------------------
+    # decrypt / encrypt credentials (lines 70-98)
+    # -----------------------------------------------------------------------
+
+    def test_should_decrypt_secret_fields_when_decrypting_api_key_credentials(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "enc_val"}
+        with patch.object(service, "extract_secret_variables", return_value=["sk"]):
+            result = service.decrypt_datasource_provider_credentials("t1", p, "org/plug", "prov")
+        assert result["sk"] == "dec_tok"
+
+    def test_should_encrypt_secret_fields_when_encrypting_api_key_credentials(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        with patch.object(service, "extract_secret_variables", return_value=["sk"]):
+            result = service.encrypt_datasource_provider_credentials("t1", "prov", "org/plug", {"sk": "plain"}, p)
+        assert result["sk"] == "enc_tok"
+        self._enc.encrypt_token.assert_called()
+
+    # -----------------------------------------------------------------------
+    # get_datasource_credentials (lines 113-165)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_empty_dict_when_credential_not_found(self, service, mock_db_session, mock_user):
+        with patch("services.datasource_provider_service.get_current_user", return_value=mock_user):
+            mock_db_session.query().first.return_value = None
+            assert service.get_datasource_credentials("t1", "prov", "org/plug") == {}
+
+    def test_should_refresh_oauth_tokens_when_expired(self, service, mock_db_session, mock_user):
+        """Expired OAuth credential (expires_at near zero) triggers a silent refresh."""
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "oauth2"
+        p.expires_at = 0  # expired
+        p.encrypted_credentials = {"tok": "x"}
+        mock_db_session.query().first.return_value = p
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "get_oauth_client", return_value={"oc": "v"}),
+            patch.object(service, "decrypt_datasource_provider_credentials", return_value={"tok": "plain"}),
+        ):
+            service.get_datasource_credentials("t1", "prov", "org/plug")
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_return_decrypted_credentials_when_api_key_not_expired(self, service, mock_db_session, mock_user):
+        """API key credentials with expires_at=-1 skip refresh and return directly."""
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        p.expires_at = -1  # sentinel: never expires
+        p.encrypted_credentials = {"k": "v"}
+        mock_db_session.query().first.return_value = p
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "decrypt_datasource_provider_credentials", return_value={"k": "plain"}),
+        ):
+            result = service.get_datasource_credentials("t1", "prov", "org/plug")
+        assert result == {"k": "plain"}
+
+    def test_should_fetch_by_credential_id_when_provided(self, service, mock_db_session, mock_user):
+        """When credential_id is passed, the credential_id filter path (line 113) is taken."""
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        p.expires_at = -1
+        p.encrypted_credentials = {}
+        mock_db_session.query().first.return_value = p
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "decrypt_datasource_provider_credentials", return_value={"k": "v"}),
+        ):
+            result = service.get_datasource_credentials("t1", "prov", "org/plug", credential_id="cred-id")
+        assert result == {"k": "v"}
+
+    # -----------------------------------------------------------------------
+    # get_all_datasource_credentials_by_provider (lines 176-228)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_empty_list_when_no_provider_credentials_exist(self, service, mock_db_session, mock_user):
+        with patch("services.datasource_provider_service.get_current_user", return_value=mock_user):
+            mock_db_session.query().all.return_value = []
+            assert service.get_all_datasource_credentials_by_provider("t1", "prov", "org/plug") == []
+
+    def test_should_refresh_and_return_credentials_when_oauth_expired(self, service, mock_db_session, mock_user):
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "oauth2"
+        p.expires_at = 0
+        p.encrypted_credentials = {"t": "x"}
+        mock_db_session.query().all.return_value = [p]
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "get_oauth_client", return_value={"oc": "v"}),
+            patch.object(service, "decrypt_datasource_provider_credentials", return_value={"t": "plain"}),
+        ):
+            result = service.get_all_datasource_credentials_by_provider("t1", "prov", "org/plug")
+        assert len(result) == 1
+
+    # -----------------------------------------------------------------------
+    # update_datasource_provider_name (lines 236-303)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_provider_not_found_on_name_update(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        with pytest.raises(ValueError, match="not found"):
+            service.update_datasource_provider_name("t1", make_id(), "new", "cred-id")
+
+    def test_should_return_early_when_new_name_matches_current(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "same"
+        mock_db_session.query().first.return_value = p
+        service.update_datasource_provider_name("t1", make_id(), "same", "cred-id")
+        mock_db_session.commit.assert_not_called()
+
+    def test_should_raise_value_error_when_name_already_exists(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "old_name"
+        p.is_default = False
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 1  # conflict
+        with pytest.raises(ValueError, match="already exists"):
+            service.update_datasource_provider_name("t1", make_id(), "new_name", "some-id")
+
+    def test_should_update_name_and_commit_when_no_conflict(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "old_name"
+        p.is_default = False
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        service.update_datasource_provider_name("t1", make_id(), "new_name", "some-id")
+        assert p.name == "new_name"
+        mock_db_session.commit.assert_called_once()
+
+    # -----------------------------------------------------------------------
+    # set_default_datasource_provider (lines 277-303)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_target_provider_not_found(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        with pytest.raises(ValueError, match="not found"):
+            service.set_default_datasource_provider("t1", make_id(), "bad-id")
+
+    def test_should_mark_target_as_default_and_commit(self, service, mock_db_session):
+        target = MagicMock(spec=DatasourceProvider)
+        target.provider = "provider"
+        target.plugin_id = "org/plug"
+        mock_db_session.query().first.return_value = target
+        service.set_default_datasource_provider("t1", make_id(), "new-id")
+        assert target.is_default is True
+        mock_db_session.commit.assert_called_once()
+
+    # -----------------------------------------------------------------------
+    # get_oauth_encrypter (lines 404-420)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_oauth_schema_missing(self, service):
+        pm = MagicMock()
+        pm.declaration.oauth_schema = None
+        with patch.object(service.provider_manager, "fetch_datasource_provider", return_value=pm):
+            with pytest.raises(ValueError, match="oauth schema not found"):
+                service.get_oauth_encrypter("t1", make_id())
+
+    def test_should_return_encrypter_when_oauth_schema_exists(self, service):
+        schema_item = MagicMock()
+        schema_item.to_basic_provider_config.return_value = MagicMock()
+        pm = MagicMock()
+        pm.declaration.oauth_schema.client_schema = [schema_item]
+        with (
+            patch.object(service.provider_manager, "fetch_datasource_provider", return_value=pm),
+            patch(
+                "services.datasource_provider_service.create_provider_encrypter",
+                return_value=(MagicMock(), MagicMock()),
+            ),
+        ):
+            result = service.get_oauth_encrypter("t1", make_id())
+        assert result is not None
+
+    # -----------------------------------------------------------------------
+    # get_tenant_oauth_client (lines 381-402)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_masked_credentials_when_mask_is_true(self, service, mock_db_session):
+        tenant_params = MagicMock()
+        tenant_params.client_params = {"k": "v"}
+        mock_db_session.query().first.return_value = tenant_params
+        with patch.object(service, "get_oauth_encrypter", return_value=(self._enc, None)):
+            result = service.get_tenant_oauth_client("t1", make_id(), mask=True)
+        assert result == {"k": "mask"}
+
+    def test_should_return_decrypted_credentials_when_mask_is_false(self, service, mock_db_session):
+        tenant_params = MagicMock()
+        tenant_params.client_params = {"k": "v"}
+        mock_db_session.query().first.return_value = tenant_params
+        with patch.object(service, "get_oauth_encrypter", return_value=(self._enc, None)):
+            result = service.get_tenant_oauth_client("t1", make_id(), mask=False)
+        assert result == {"k": "dec"}
+
+    def test_should_return_none_when_no_tenant_oauth_config_exists(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        assert service.get_tenant_oauth_client("t1", make_id()) is None
+
+    # -----------------------------------------------------------------------
+    # get_oauth_client (lines 423-457)
+    # -----------------------------------------------------------------------
+
+    def test_should_use_tenant_config_when_available(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = MagicMock(client_params={"k": "v"})
+        with patch.object(service, "get_oauth_encrypter", return_value=(self._enc, None)):
+            result = service.get_oauth_client("t1", make_id())
+        assert result == {"k": "dec"}
+
+    def test_should_fallback_to_system_credentials_when_tenant_config_missing(self, service, mock_db_session):
+        mock_db_session.query().first.side_effect = [None, MagicMock(system_credentials={"k": "sys"})]
+        with (
+            patch.object(service.provider_manager, "fetch_datasource_provider"),
+            patch("services.datasource_provider_service.PluginService.is_plugin_verified", return_value=True),
+        ):
+            result = service.get_oauth_client("t1", make_id())
+        assert result == {"k": "sys"}
+
+    def test_should_raise_value_error_when_no_oauth_config_available(self, service, mock_db_session):
+        """Neither tenant nor system credentials → raises ValueError."""
+        mock_db_session.query().first.side_effect = [None, None]
+        with (
+            patch.object(service.provider_manager, "fetch_datasource_provider"),
+            patch("services.datasource_provider_service.PluginService.is_plugin_verified", return_value=False),
+        ):
+            with pytest.raises(ValueError, match="Please configure oauth client params"):
+                service.get_oauth_client("t1", make_id())
+
+    # -----------------------------------------------------------------------
+    # add_datasource_oauth_provider (lines 539-607)
+    # -----------------------------------------------------------------------
+
+    def test_should_add_oauth_provider_successfully_when_name_is_unique(self, service, mock_db_session):
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=[]):
+            service.add_datasource_oauth_provider("new", "t1", make_id(), "http://cb", 9999, {})
+        mock_db_session.add.assert_called_once()
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_auto_rename_when_oauth_provider_name_conflicts(self, service, mock_db_session):
+        """Conflict on name results in auto-incremented name, not an error."""
+        mock_db_session.query().count.return_value = 1  # conflict first, then auto-named
+        mock_db_session.query().all.return_value = []
+        with (
+            patch.object(service, "extract_secret_variables", return_value=[]),
+            patch.object(service, "generate_next_datasource_provider_name", return_value="new_gen"),
+        ):
+            service.add_datasource_oauth_provider("conflict", "t1", make_id(), "http://cb", 9999, {})
+        mock_db_session.add.assert_called_once()
+
+    def test_should_auto_generate_name_when_none_provided_for_oauth(self, service, mock_db_session):
+        """name=None causes auto-generation via generate_next_datasource_provider_name."""
+        mock_db_session.query().count.return_value = 0
+        mock_db_session.query().all.return_value = []
+        with (
+            patch.object(service, "extract_secret_variables", return_value=[]),
+            patch.object(service, "generate_next_datasource_provider_name", return_value="auto"),
+        ):
+            service.add_datasource_oauth_provider(None, "t1", make_id(), "http://cb", 9999, {})
+        mock_db_session.add.assert_called_once()
+
+    def test_should_encrypt_secret_fields_when_adding_oauth_provider(self, service, mock_db_session):
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=["secret_key"]):
+            service.add_datasource_oauth_provider("nm", "t1", make_id(), "http://cb", 9999, {"secret_key": "value"})
+        self._enc.encrypt_token.assert_called()
+
+    def test_should_acquire_redis_lock_when_adding_oauth_provider(self, service, mock_db_session):
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=[]):
+            service.add_datasource_oauth_provider("nm", "t1", make_id(), "http://cb", 9999, {})
+        self._redis.lock.assert_called()
+
+    # -----------------------------------------------------------------------
+    # reauthorize_datasource_oauth_provider (lines 477-537)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_credential_id_not_found_on_reauth(self, service, mock_db_session):
+        mock_db_session.query().first.return_value = None
+        with patch.object(service, "extract_secret_variables", return_value=[]):
+            with pytest.raises(ValueError, match="not found"):
+                service.reauthorize_datasource_oauth_provider("n", "t1", make_id(), "u", 1, {}, "bad-id")
+
+    def test_should_reauthorize_and_commit_when_credential_found(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=[]):
+            service.reauthorize_datasource_oauth_provider("n", "t1", make_id(), "u", 1, {}, "oid")
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_auto_rename_when_reauth_name_conflicts(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 1  # conflict
+        mock_db_session.query().all.return_value = []
+        with patch.object(service, "extract_secret_variables", return_value=["tok"]):
+            service.reauthorize_datasource_oauth_provider(
+                "conflict_name", "t1", make_id(), "u", 9999, {"tok": "v"}, "cred-id"
+            )
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_encrypt_secret_fields_when_reauthorizing(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=["tok"]):
+            service.reauthorize_datasource_oauth_provider(None, "t1", make_id(), "u", 9999, {"tok": "val"}, "cred-id")
+        self._enc.encrypt_token.assert_called()
+
+    def test_should_acquire_redis_lock_when_reauthorizing(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        with patch.object(service, "extract_secret_variables", return_value=[]):
+            service.reauthorize_datasource_oauth_provider("n", "t1", make_id(), "u", 1, {}, "oid")
+        self._redis.lock.assert_called()
+
+    # -----------------------------------------------------------------------
+    # add_datasource_api_key_provider (lines 608-675)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_api_key_name_already_exists(self, service, mock_db_session, mock_user):
+        """explicit name supplied + conflict → raises ValueError immediately."""
+        mock_db_session.query().count.return_value = 1
+        with patch("services.datasource_provider_service.get_current_user", return_value=mock_user):
+            with pytest.raises(ValueError, match="already exists"):
+                service.add_datasource_api_key_provider("clash", "t1", make_id(), {"sk": "v"})
+
+    def test_should_raise_value_error_when_credentials_validation_fails(self, service, mock_db_session, mock_user):
+        mock_db_session.query().count.return_value = 0
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service.provider_manager, "validate_provider_credentials", side_effect=Exception("bad cred")),
+            patch.object(service, "extract_secret_variables", return_value=[]),
+        ):
+            with pytest.raises(ValueError, match="Failed to validate"):
+                service.add_datasource_api_key_provider("nm", "t1", make_id(), {"k": "v"})
+
+    def test_should_add_api_key_provider_and_commit_when_valid(self, service, mock_db_session, mock_user):
+        mock_db_session.query().count.return_value = 0
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service.provider_manager, "validate_provider_credentials"),
+            patch.object(service, "extract_secret_variables", return_value=["sk"]),
+        ):
+            service.add_datasource_api_key_provider(None, "t1", make_id(), {"sk": "v"})
+        mock_db_session.add.assert_called_once()
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_acquire_redis_lock_when_adding_api_key_provider(self, service, mock_db_session, mock_user):
+        mock_db_session.query().count.return_value = 0
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service.provider_manager, "validate_provider_credentials"),
+            patch.object(service, "extract_secret_variables", return_value=[]),
+        ):
+            service.add_datasource_api_key_provider(None, "t1", make_id(), {})
+        self._redis.lock.assert_called()
+
+    # -----------------------------------------------------------------------
+    # extract_secret_variables (lines 666-699)
+    # -----------------------------------------------------------------------
+
+    def test_should_extract_secret_variable_names_for_api_key_schema(self, service):
+        schema = MagicMock()
+        schema.name = "my_secret"
+        schema.type = MagicMock()
+        schema.type.value = FormType.SECRET_INPUT  # "secret-input"
+        pm = MagicMock()
+        pm.declaration.credentials_schema = [schema]
+        with patch.object(service.provider_manager, "fetch_datasource_provider", return_value=pm):
+            result = service.extract_secret_variables("t1", "org/plug/prov", CredentialType.API_KEY)
+        assert "my_secret" in result
+
+    def test_should_extract_secret_variable_names_for_oauth2_schema(self, service):
+        schema = MagicMock()
+        schema.name = "oauth_secret"
+        schema.type = MagicMock()
+        schema.type.value = FormType.SECRET_INPUT
+        pm = MagicMock()
+        pm.declaration.oauth_schema.credentials_schema = [schema]
+        with patch.object(service.provider_manager, "fetch_datasource_provider", return_value=pm):
+            result = service.extract_secret_variables("t1", "org/plug/prov", CredentialType.OAUTH2)
+        assert "oauth_secret" in result
+
+    def test_should_raise_value_error_when_credential_type_is_invalid(self, service):
+        pm = MagicMock()
+        with patch.object(service.provider_manager, "fetch_datasource_provider", return_value=pm):
+            with pytest.raises(ValueError, match="Invalid credential type"):
+                service.extract_secret_variables("t1", "org/plug/prov", CredentialType.UNAUTHORIZED)
+
+    # -----------------------------------------------------------------------
+    # list_datasource_credentials (lines 721-754)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_empty_list_when_no_credentials_stored(self, service, mock_db_session):
+        mock_db_session.query().all.return_value = []
+        assert service.list_datasource_credentials("t1", "prov", "org/plug") == []
+
+    def test_should_return_masked_credentials_list_when_credentials_exist(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "v"}
+        p.is_default = False
+        mock_db_session.query().all.return_value = [p]
+        with patch.object(service, "extract_secret_variables", return_value=["sk"]):
+            result = service.list_datasource_credentials("t1", "prov", "org/plug")
+        assert len(result) == 1
+
+    # -----------------------------------------------------------------------
+    # get_all_datasource_credentials (lines 808-871)
+    # -----------------------------------------------------------------------
+
+    def test_should_aggregate_credentials_for_non_hardcoded_plugin(self, service):
+        with patch("services.datasource_provider_service.PluginDatasourceManager") as mock_mgr:
+            ds = MagicMock()
+            ds.provider = "prov"
+            ds.plugin_id = "org/plug"
+            ds.declaration.identity.label.model_dump.return_value = {"en_US": "Label"}
+            mock_mgr.return_value.fetch_installed_datasource_providers.return_value = [ds]
+            cred = {"credential": {"k": "v"}, "is_default": True}
+            with patch.object(service, "list_datasource_credentials", return_value=[cred]):
+                results = service.get_all_datasource_credentials("t1")
+        assert len(results) == 1
+
+    def test_should_include_oauth_schema_for_hardcoded_plugin_ids(self, service, mock_db_session):
+        """Lines 819-871: get_all_datasource_credentials covers hardcoded langgenius plugin IDs."""
+        with patch("services.datasource_provider_service.PluginDatasourceManager") as mock_mgr:
+            ds = MagicMock()
+            ds.plugin_id = "langgenius/firecrawl_datasource"
+            ds.provider = "firecrawl"
+            ds.plugin_unique_identifier = "pui"
+            ds.declaration.identity.icon = "icon"
+            ds.declaration.identity.name = "langgenius/firecrawl_datasource"
+            ds.declaration.identity.label.model_dump.return_value = {"en_US": "Firecrawl"}
+            ds.declaration.identity.description.model_dump.return_value = {"en_US": "desc"}
+            ds.declaration.identity.author = "langgenius"
+            ds.declaration.credentials_schema = []
+            ds.declaration.oauth_schema.client_schema = []
+            ds.declaration.oauth_schema.credentials_schema = []
+            mock_mgr.return_value.fetch_installed_datasource_providers.return_value = [ds]
+            with (
+                patch.object(service, "list_datasource_credentials", return_value=[]),
+                patch.object(service, "get_tenant_oauth_client", return_value=None),
+                patch.object(service, "is_tenant_oauth_params_enabled", return_value=False),
+                patch.object(service, "is_system_oauth_params_exist", return_value=False),
+            ):
+                results = service.get_all_datasource_credentials("t1")
+        assert len(results) == 1
+        assert results[0]["oauth_schema"] is not None
+
+    # -----------------------------------------------------------------------
+    # get_real_datasource_credentials (lines 873-915)
+    # -----------------------------------------------------------------------
+
+    def test_should_return_empty_list_when_no_real_credentials_exist(self, service, mock_db_session):
+        mock_db_session.query().all.return_value = []
+        assert service.get_real_datasource_credentials("t1", "prov", "org/plug") == []
+
+    def test_should_return_decrypted_credential_list_when_credentials_exist(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "v"}
+        mock_db_session.query().all.return_value = [p]
+        with patch.object(service, "extract_secret_variables", return_value=["sk"]):
+            result = service.get_real_datasource_credentials("t1", "prov", "org/plug")
+        assert len(result) == 1
+
+    # -----------------------------------------------------------------------
+    # update_datasource_credentials (lines 917-978)
+    # -----------------------------------------------------------------------
+
+    def test_should_raise_value_error_when_credential_not_found_on_update(self, service, mock_db_session, mock_user):
+        mock_db_session.query().first.return_value = None
+        with patch("services.datasource_provider_service.get_current_user", return_value=mock_user):
+            with pytest.raises(ValueError, match="not found"):
+                service.update_datasource_credentials("t1", "id", "prov", "org/plug", {}, "name")
+
+    def test_should_raise_value_error_when_new_name_already_used_on_update(self, service, mock_db_session, mock_user):
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "old_name"
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "e"}
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 1
+        with patch("services.datasource_provider_service.get_current_user", return_value=mock_user):
+            with pytest.raises(ValueError, match="already exists"):
+                service.update_datasource_credentials("t1", "id", "prov", "org/plug", {}, "new_name")
+
+    def test_should_raise_value_error_when_credential_validation_fails_on_update(
+        self, service, mock_db_session, mock_user
+    ):
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "old_name"
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "e"}
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "extract_secret_variables", return_value=["sk"]),
+            patch.object(service.provider_manager, "validate_provider_credentials", side_effect=Exception("bad")),
+        ):
+            with pytest.raises(ValueError, match="Failed to validate"):
+                service.update_datasource_credentials("t1", "id", "prov", "org/plug", {"sk": "v"}, "name")
+
+    def test_should_encrypt_credentials_and_commit_when_update_succeeds(self, service, mock_db_session, mock_user):
+        """Verifies that encrypted_credentials is reassigned with encrypted value and commit is called."""
+        p = MagicMock(spec=DatasourceProvider)
+        p.name = "old_name"
+        p.auth_type = "api_key"
+        p.encrypted_credentials = {"sk": "old_enc"}
+        mock_db_session.query().first.return_value = p
+        mock_db_session.query().count.return_value = 0
+        with (
+            patch("services.datasource_provider_service.get_current_user", return_value=mock_user),
+            patch.object(service, "extract_secret_variables", return_value=["sk"]),
+            patch.object(service.provider_manager, "validate_provider_credentials"),
+        ):
+            service.update_datasource_credentials("t1", "id", "prov", "org/plug", {"sk": "new_val"}, "name")
+        # encrypter must have been called with the new secret value
+        self._enc.encrypt_token.assert_called()
+        # commit must be called exactly once
+        mock_db_session.commit.assert_called_once()
+
+    # -----------------------------------------------------------------------
+    # remove_datasource_credentials (lines 980-997)
+    # -----------------------------------------------------------------------
+
+    def test_should_delete_provider_and_commit_when_found(self, service, mock_db_session):
+        p = MagicMock(spec=DatasourceProvider)
+        mock_db_session.query().first.return_value = p
+        service.remove_datasource_credentials("t1", "id", "prov", "org/plug")
+        mock_db_session.delete.assert_called_once_with(p)
+        mock_db_session.commit.assert_called_once()
+
+    def test_should_do_nothing_when_credential_not_found_on_remove(self, service, mock_db_session):
+        """No error raised; no delete called when record doesn't exist (lines 994 branch)."""
+        mock_db_session.query().first.return_value = None
+        service.remove_datasource_credentials("t1", "id", "prov", "org/plug")
+        mock_db_session.delete.assert_not_called()

api/tests/unit_tests/services/test_hit_testing_service.py

@@ -0,0 +1,385 @@
+import json
+from typing import Any, cast
+from unittest.mock import ANY, MagicMock, patch
+
+import pytest
+
+from core.rag.models.document import Document
+from models.dataset import Dataset
+from services.hit_testing_service import HitTestingService
+
+
+class TestHitTestingService:
+    """Test suite for HitTestingService"""
+
+    # ===== Utility Method Tests =====
+
+    def test_escape_query_for_search_should_escape_double_quotes(self):
+        """Test that escape_query_for_search escapes double quotes correctly"""
+        # Arrange
+        query = 'test "query" with quotes'
+        expected = 'test \\"query\\" with quotes'
+
+        # Act
+        result = HitTestingService.escape_query_for_search(query)
+
+        # Assert
+        assert result == expected
+
+    def test_hit_testing_args_check_should_pass_with_valid_query(self):
+        """Test that hit_testing_args_check passes with a valid query"""
+        # Arrange
+        args = {"query": "valid query"}
+
+        # Act & Assert (should not raise)
+        HitTestingService.hit_testing_args_check(args)
+
+    def test_hit_testing_args_check_should_pass_with_valid_attachments(self):
+        """Test that hit_testing_args_check passes with valid attachment_ids"""
+        # Arrange
+        args = {"attachment_ids": ["id1", "id2"]}
+
+        # Act & Assert (should not raise)
+        HitTestingService.hit_testing_args_check(args)
+
+    def test_hit_testing_args_check_should_raise_error_when_no_query_or_attachments(self):
+        """Test that hit_testing_args_check raises ValueError if both query and attachment_ids are missing"""
+        # Arrange
+        args = {}
+
+        # Act & Assert
+        with pytest.raises(ValueError) as exc_info:
+            HitTestingService.hit_testing_args_check(args)
+        assert "Query or attachment_ids is required" in str(exc_info.value)
+
+    def test_hit_testing_args_check_should_raise_error_when_query_too_long(self):
+        """Test that hit_testing_args_check raises ValueError if query exceeds 250 characters"""
+        # Arrange
+        args = {"query": "a" * 251}
+
+        # Act & Assert
+        with pytest.raises(ValueError) as exc_info:
+            HitTestingService.hit_testing_args_check(args)
+        assert "Query cannot exceed 250 characters" in str(exc_info.value)
+
+    def test_hit_testing_args_check_should_raise_error_when_attachments_not_list(self):
+        """Test that hit_testing_args_check raises ValueError if attachment_ids is not a list"""
+        # Arrange
+        args = {"attachment_ids": "not a list"}
+
+        # Act & Assert
+        with pytest.raises(ValueError) as exc_info:
+            HitTestingService.hit_testing_args_check(args)
+        assert "Attachment_ids must be a list" in str(exc_info.value)
+
+    # ===== Response Formatting Tests =====
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.format_retrieval_documents")
+    def test_compact_retrieve_response_should_format_correctly(self, mock_format):
+        """Test that compact_retrieve_response formats the response correctly"""
+        # Arrange
+        query = "test query"
+        mock_doc = MagicMock(spec=Document)
+        documents = [mock_doc]
+
+        mock_record = MagicMock()
+        mock_record.model_dump.return_value = {"content": "formatted content"}
+        mock_format.return_value = [mock_record]
+
+        # Act
+        result = cast(dict[str, Any], HitTestingService.compact_retrieve_response(query, documents))
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        assert len(result["records"]) == 1
+        assert cast(dict[str, Any], result["records"][0])["content"] == "formatted content"
+        mock_format.assert_called_once_with(documents)
+
+    def test_compact_external_retrieve_response_should_return_records_for_external_provider(self):
+        """Test that compact_external_retrieve_response returns records when dataset provider is external"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.provider = "external"
+        query = "test query"
+        documents = [
+            {"content": "c1", "title": "t1", "score": 0.9, "metadata": {"m1": "v1"}},
+            {"content": "c2", "title": "t2", "score": 0.8, "metadata": {"m2": "v2"}},
+        ]
+
+        # Act
+        result = cast(dict[str, Any], HitTestingService.compact_external_retrieve_response(dataset, query, documents))
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        assert len(result["records"]) == 2
+        assert cast(dict[str, Any], result["records"][0])["content"] == "c1"
+        assert cast(dict[str, Any], result["records"][1])["title"] == "t2"
+
+    def test_compact_external_retrieve_response_should_return_empty_for_non_external_provider(self):
+        """Test that compact_external_retrieve_response returns empty records for non-external provider"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.provider = "not_external"
+        query = "test query"
+        documents = [{"content": "c1"}]
+
+        # Act
+        result = cast(dict[str, Any], HitTestingService.compact_external_retrieve_response(dataset, query, documents))
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        assert result["records"] == []
+
+    # ===== External Retrieve Tests =====
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.external_retrieve")
+    @patch("extensions.ext_database.db.session.add")
+    @patch("extensions.ext_database.db.session.commit")
+    def test_external_retrieve_should_succeed_for_external_provider(self, mock_commit, mock_add, mock_ext_retrieve):
+        """Test that external_retrieve successfully retrieves from external provider and commits query"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        dataset.provider = "external"
+        query = 'test "query"'
+        account = MagicMock()
+        account.id = "account_id"
+
+        mock_ext_retrieve.return_value = [{"content": "ext content", "score": 1.0}]
+
+        # Act
+        result = cast(
+            dict[str, Any],
+            HitTestingService.external_retrieve(
+                dataset=dataset,
+                query=query,
+                account=account,
+                external_retrieval_model={"model": "test"},
+                metadata_filtering_conditions={"key": "val"},
+            ),
+        )
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        assert cast(dict[str, Any], result["records"][0])["content"] == "ext content"
+
+        # Verify call to RetrievalService.external_retrieve with escaped query
+        mock_ext_retrieve.assert_called_once_with(
+            dataset_id="dataset_id",
+            query='test \\"query\\"',
+            external_retrieval_model={"model": "test"},
+            metadata_filtering_conditions={"key": "val"},
+        )
+
+        # Verify DatasetQuery record was added and committed
+        mock_add.assert_called_once()
+        mock_commit.assert_called_once()
+
+    def test_external_retrieve_should_return_empty_for_non_external_provider(self):
+        """Test that external_retrieve returns empty results immediately if provider is not external"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.provider = "not_external"
+        query = "test query"
+        account = MagicMock()
+
+        # Act
+        result = cast(dict[str, Any], HitTestingService.external_retrieve(dataset, query, account))
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        assert result["records"] == []
+
+    # ===== Retrieve Tests =====
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.retrieve")
+    @patch("extensions.ext_database.db.session.add")
+    @patch("extensions.ext_database.db.session.commit")
+    def test_retrieve_should_use_default_model_when_none_provided(self, mock_commit, mock_add, mock_retrieve):
+        """Test that retrieve uses default model when retrieval_model is not provided"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        dataset.retrieval_model = None
+        query = "test query"
+        account = MagicMock()
+        account.id = "account_id"
+
+        mock_retrieve.return_value = []
+
+        # Act
+        result = cast(
+            dict[str, Any],
+            HitTestingService.retrieve(
+                dataset=dataset, query=query, account=account, retrieval_model=None, external_retrieval_model={}
+            ),
+        )
+
+        # Assert
+        assert cast(dict[str, Any], result["query"])["content"] == query
+        mock_retrieve.assert_called_once()
+        # Verify top_k from default_retrieval_model (4)
+        assert mock_retrieve.call_args.kwargs["top_k"] == 4
+        mock_commit.assert_called_once()
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.retrieve")
+    @patch("core.rag.retrieval.dataset_retrieval.DatasetRetrieval.get_metadata_filter_condition")
+    @patch("extensions.ext_database.db.session.add")
+    @patch("extensions.ext_database.db.session.commit")
+    def test_retrieve_should_handle_metadata_filtering(self, mock_commit, mock_add, mock_get_meta, mock_retrieve):
+        """Test that retrieve correctly calls metadata filtering when conditions are present"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        query = "test query"
+        account = MagicMock()
+        account.id = "account_id"
+
+        retrieval_model = {
+            "search_method": "semantic_search",
+            "metadata_filtering_conditions": {"some": "condition"},
+            "top_k": 5,
+            "reranking_enable": False,
+            "score_threshold_enabled": False,
+        }
+
+        # Mock metadata filtering response
+        mock_get_meta.return_value = ({"dataset_id": ["doc_id1"]}, "condition_string")
+        mock_retrieve.return_value = []
+
+        # Act
+        HitTestingService.retrieve(
+            dataset=dataset, query=query, account=account, retrieval_model=retrieval_model, external_retrieval_model={}
+        )
+
+        # Assert
+        mock_get_meta.assert_called_once()
+        mock_retrieve.assert_called_once()
+        assert mock_retrieve.call_args.kwargs["document_ids_filter"] == ["doc_id1"]
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.retrieve")
+    @patch("core.rag.retrieval.dataset_retrieval.DatasetRetrieval.get_metadata_filter_condition")
+    def test_retrieve_should_return_empty_if_metadata_filtering_fails(self, mock_get_meta, mock_retrieve):
+        """Test that retrieve returns empty response if metadata filtering returns condition but no document IDs"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        query = "test query"
+        account = MagicMock()
+
+        retrieval_model = {
+            "search_method": "semantic_search",
+            "metadata_filtering_conditions": {"some": "condition"},
+            "top_k": 5,
+            "reranking_enable": False,
+            "score_threshold_enabled": False,
+        }
+
+        # Mock metadata filtering response: condition returned but no IDs
+        mock_get_meta.return_value = ({}, "condition_string")
+
+        # Act
+        result = cast(
+            dict[str, Any],
+            HitTestingService.retrieve(
+                dataset=dataset,
+                query=query,
+                account=account,
+                retrieval_model=retrieval_model,
+                external_retrieval_model={},
+            ),
+        )
+
+        # Assert
+        assert result["records"] == []
+        mock_retrieve.assert_not_called()
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.retrieve")
+    @patch("extensions.ext_database.db.session.add")
+    @patch("extensions.ext_database.db.session.commit")
+    def test_retrieve_should_handle_attachments(self, mock_commit, mock_add, mock_retrieve):
+        """Test that retrieve handles attachment_ids and adds them to DatasetQuery"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        query = "test query"
+        account = MagicMock()
+        account.id = "account_id"
+        attachment_ids = ["att1", "att2"]
+
+        retrieval_model = {
+            "search_method": "semantic_search",
+            "top_k": 4,
+            "reranking_enable": False,
+            "score_threshold_enabled": False,
+        }
+        mock_retrieve.return_value = []
+
+        # Act
+        HitTestingService.retrieve(
+            dataset=dataset,
+            query=query,
+            account=account,
+            retrieval_model=retrieval_model,
+            external_retrieval_model={},
+            attachment_ids=attachment_ids,
+        )
+
+        # Assert
+        mock_retrieve.assert_called_once_with(
+            retrieval_method=ANY,
+            dataset_id="dataset_id",
+            query=query,
+            attachment_ids=attachment_ids,
+            top_k=4,
+            score_threshold=0.0,
+            reranking_model=None,
+            reranking_mode="reranking_model",
+            weights=None,
+            document_ids_filter=None,
+        )
+        # Verify DatasetQuery record (there should be 2 queries: 1 text, 2 images)
+        # The content is json.dumps([{"content_type": "text_query", ...}, {"content_type": "image_query", ...}])
+        called_query = mock_add.call_args[0][0]
+        query_content = json.loads(called_query.content)
+        assert len(query_content) == 3  # 1 text + 2 images
+        assert query_content[0]["content_type"] == "text_query"
+        assert query_content[1]["content_type"] == "image_query"
+        assert query_content[1]["content"] == "att1"
+
+    @patch("core.rag.datasource.retrieval_service.RetrievalService.retrieve")
+    @patch("extensions.ext_database.db.session.add")
+    @patch("extensions.ext_database.db.session.commit")
+    def test_retrieve_should_handle_reranking_and_threshold(self, mock_commit, mock_add, mock_retrieve):
+        """Test that retrieve passes reranking and threshold parameters correctly"""
+        # Arrange
+        dataset = MagicMock(spec=Dataset)
+        dataset.id = "dataset_id"
+        query = "test query"
+        account = MagicMock()
+        account.id = "account_id"
+
+        retrieval_model = {
+            "search_method": "hybrid_search",
+            "top_k": 10,
+            "reranking_enable": True,
+            "reranking_model": {"provider": "test"},
+            "reranking_mode": "weighted_sum",
+            "score_threshold_enabled": True,
+            "score_threshold": 0.5,
+            "weights": {"vector": 0.5, "keyword": 0.5},
+        }
+        mock_retrieve.return_value = []
+
+        # Act
+        HitTestingService.retrieve(
+            dataset=dataset, query=query, account=account, retrieval_model=retrieval_model, external_retrieval_model={}
+        )
+
+        # Assert
+        mock_retrieve.assert_called_once()
+        kwargs = mock_retrieve.call_args.kwargs
+        assert kwargs["score_threshold"] == 0.5
+        assert kwargs["reranking_model"] == {"provider": "test"}
+        assert kwargs["reranking_mode"] == "weighted_sum"
+        assert kwargs["weights"] == {"vector": 0.5, "keyword": 0.5}

api/tests/unit_tests/services/test_knowledge_service.py

@@ -0,0 +1,146 @@
+from typing import Any, cast
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from services.knowledge_service import ExternalDatasetTestService
+
+
+class TestKnowledgeService:
+    """Test suite for ExternalDatasetTestService"""
+
+    # ===== Happy Path Tests =====
+
+    @patch("services.knowledge_service.boto3.client")
+    @patch("services.knowledge_service.dify_config")
+    def test_knowledge_retrieval_should_succeed_with_valid_results(
+        self, mock_dify_config: MagicMock, mock_boto_client: MagicMock
+    ):
+        """Test that knowledge_retrieval successfully parses results from Bedrock"""
+        # Arrange
+        mock_dify_config.AWS_SECRET_ACCESS_KEY = "dummy_secret"
+        mock_dify_config.AWS_ACCESS_KEY_ID = "dummy_id"
+
+        mock_client = MagicMock()
+        mock_boto_client.return_value = mock_client
+
+        retrieval_setting = {"top_k": 4, "score_threshold": 0.5}
+        query = "test query"
+        knowledge_id = "kb-123"
+
+        # Mock successful response
+        mock_client.retrieve.return_value = {
+            "ResponseMetadata": {"HTTPStatusCode": 200},
+            "retrievalResults": [
+                {
+                    "score": 0.9,
+                    "metadata": {"x-amz-bedrock-kb-source-uri": "s3://bucket/doc1.pdf"},
+                    "content": {"text": "content from doc1"},
+                },
+                {
+                    "score": 0.4,  # Below threshold
+                    "metadata": {"x-amz-bedrock-kb-source-uri": "s3://bucket/doc2.pdf"},
+                    "content": {"text": "content from doc2"},
+                },
+            ],
+        }
+
+        # Act
+        result = cast(
+            dict[str, Any], ExternalDatasetTestService.knowledge_retrieval(retrieval_setting, query, knowledge_id)
+        )
+
+        # Assert
+        assert len(result["records"]) == 1
+        record = result["records"][0]
+        assert record["score"] == 0.9
+        assert record["title"] == "s3://bucket/doc1.pdf"
+        assert record["content"] == "content from doc1"
+
+        # verify retrieve called correctly
+        mock_client.retrieve.assert_called_once_with(
+            knowledgeBaseId=knowledge_id,
+            retrievalConfiguration={
+                "vectorSearchConfiguration": {
+                    "numberOfResults": 4,
+                    "overrideSearchType": "HYBRID",
+                }
+            },
+            retrievalQuery={"text": query},
+        )
+
+        # NEW: verify boto3.client created with proper service name and config values
+        mock_boto_client.assert_called_once_with(
+            "bedrock-agent-runtime",
+            aws_secret_access_key="dummy_secret",
+            aws_access_key_id="dummy_id",
+            region_name="us-east-1",
+        )
+
+    @patch("services.knowledge_service.boto3.client")
+    def test_knowledge_retrieval_should_return_empty_when_no_results(self, mock_boto: MagicMock):
+        """Test that knowledge_retrieval returns empty records when Bedrock returns nothing"""
+        # Arrange
+        mock_client = MagicMock()
+        mock_boto.return_value = mock_client
+
+        mock_client.retrieve.return_value = {"ResponseMetadata": {"HTTPStatusCode": 200}, "retrievalResults": []}
+
+        # Act
+        result = cast(dict[str, Any], ExternalDatasetTestService.knowledge_retrieval({"top_k": 1}, "query", "kb"))
+
+        # Assert
+        assert result["records"] == []
+
+    # ===== Error Handling Tests =====
+
+    @patch("services.knowledge_service.boto3.client")
+    def test_knowledge_retrieval_should_return_empty_on_http_error(self, mock_boto: MagicMock):
+        """Test that knowledge_retrieval returns empty records if Bedrock returns non-200 status"""
+        # Arrange
+        mock_client = MagicMock()
+        mock_boto.return_value = mock_client
+
+        mock_client.retrieve.return_value = {"ResponseMetadata": {"HTTPStatusCode": 500}}
+
+        # Act
+        result = cast(dict[str, Any], ExternalDatasetTestService.knowledge_retrieval({"top_k": 1}, "query", "kb"))
+
+        # Assert
+        assert result["records"] == []
+
+    def test_knowledge_retrieval_should_raise_when_boto_client_creation_fails(self):
+        """Test that exceptions from boto3.client propagate (e.g., network/credentials issues)"""
+        with patch("services.knowledge_service.boto3.client") as mock_boto:
+            mock_boto.side_effect = Exception("client init failed")
+            with pytest.raises(Exception) as exc_info:
+                ExternalDatasetTestService.knowledge_retrieval({"top_k": 1}, "query", "kb")
+            assert "client init failed" in str(exc_info.value)
+
+    # ===== Edge Cases =====
+
+    @patch("services.knowledge_service.boto3.client")
+    def test_knowledge_retrieval_should_handle_missing_threshold_in_settings(self, mock_boto: MagicMock):
+        """Test that knowledge_retrieval uses 0.0 as default threshold if not provided"""
+        # Arrange
+        mock_client = MagicMock()
+        mock_boto.return_value = mock_client
+
+        mock_client.retrieve.return_value = {
+            "ResponseMetadata": {"HTTPStatusCode": 200},
+            "retrievalResults": [
+                {
+                    "score": 0.1,
+                    "metadata": {"x-amz-bedrock-kb-source-uri": "uri"},
+                    "content": {"text": "text"},
+                }
+            ],
+        }
+
+        # Act
+        # retrieval_setting missing "score_threshold"
+        result = cast(dict[str, Any], ExternalDatasetTestService.knowledge_retrieval({"top_k": 1}, "query", "kb"))
+
+        # Assert
+        assert len(result["records"]) == 1
+        assert result["records"][0]["score"] == 0.1

api/tests/unit_tests/services/test_operation_service.py

@@ -0,0 +1,120 @@
+from unittest.mock import MagicMock, patch
+
+import httpx
+import pytest
+
+from services.operation_service import OperationService
+
+
+class TestOperationService:
+    """Test suite for OperationService"""
+
+    # ===== Internal Method Tests =====
+
+    @patch("httpx.request")
+    def test_should_call_with_correct_parameters_when__send_request_invoked(
+        self, mock_request: MagicMock, monkeypatch: pytest.MonkeyPatch
+    ):
+        """Test that _send_request calls httpx.request with the correct URL, headers, and data"""
+        # Arrange
+        monkeypatch.setattr(OperationService, "base_url", "https://billing.example")
+        monkeypatch.setattr(OperationService, "secret_key", "s3cr3t")
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"status": "success"}
+        mock_request.return_value = mock_response
+
+        method = "POST"
+        endpoint = "/test_endpoint"
+        json_data = {"key": "value"}
+
+        # Act
+        result = OperationService._send_request(method, endpoint, json=json_data)
+
+        # Assert
+        assert result == {"status": "success"}
+
+        # Verify call parameters
+        expected_url = "https://billing.example/test_endpoint"
+        mock_request.assert_called_once()
+        args, kwargs = mock_request.call_args
+        assert args[0] == method
+        assert args[1] == expected_url
+        assert kwargs["json"] == json_data
+        assert kwargs["headers"]["Billing-Api-Secret-Key"] == "s3cr3t"
+        assert kwargs["headers"]["Content-Type"] == "application/json"
+
+    @patch("httpx.request")
+    def test_should_propagate_httpx_error_when__send_request_raises(
+        self, mock_request: MagicMock, monkeypatch: pytest.MonkeyPatch
+    ):
+        """Test that _send_request handles httpx raising an error"""
+        # Arrange
+        monkeypatch.setattr(OperationService, "base_url", "https://billing.example")
+        mock_request.side_effect = httpx.RequestError("network error")
+
+        # Act & Assert
+        with pytest.raises(httpx.RequestError):
+            OperationService._send_request("POST", "/test")
+
+    # ===== Public Method Tests =====
+
+    @pytest.mark.parametrize(
+        ("utm_info", "expected_params"),
+        [
+            (
+                {
+                    "utm_source": "google",
+                    "utm_medium": "cpc",
+                    "utm_campaign": "spring_sale",
+                    "utm_content": "ad_1",
+                    "utm_term": "ai_agent",
+                },
+                {
+                    "tenant_id": "tenant-123",
+                    "utm_source": "google",
+                    "utm_medium": "cpc",
+                    "utm_campaign": "spring_sale",
+                    "utm_content": "ad_1",
+                    "utm_term": "ai_agent",
+                },
+            ),
+            (
+                {},  # Empty utm_info
+                {
+                    "tenant_id": "tenant-123",
+                    "utm_source": "",
+                    "utm_medium": "",
+                    "utm_campaign": "",
+                    "utm_content": "",
+                    "utm_term": "",
+                },
+            ),
+            (
+                {"utm_source": "newsletter"},  # Partial utm_info
+                {
+                    "tenant_id": "tenant-123",
+                    "utm_source": "newsletter",
+                    "utm_medium": "",
+                    "utm_campaign": "",
+                    "utm_content": "",
+                    "utm_term": "",
+                },
+            ),
+        ],
+    )
+    @patch.object(OperationService, "_send_request")
+    def test_should_map_parameters_correctly_when_record_utm_called(
+        self, mock_send: MagicMock, utm_info: dict, expected_params: dict
+    ):
+        """Test that record_utm correctly maps utm_info to parameters and calls _send_request"""
+        # Arrange
+        tenant_id = "tenant-123"
+        mock_send.return_value = {"status": "recorded"}
+
+        # Act
+        result = OperationService.record_utm(tenant_id, utm_info)
+
+        # Assert
+        assert result == {"status": "recorded"}
+        mock_send.assert_called_once_with("POST", "/tenant_utms", params=expected_params)

sdks/nodejs-client/package.json

@@ -54,17 +54,22 @@
     "publish:npm": "./scripts/publish.sh"
   },
   "dependencies": {
-    "axios": "^1.13.2"
+    "axios": "^1.13.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.50.1",
-    "@typescript-eslint/parser": "^8.50.1",
-    "@vitest/coverage-v8": "4.0.16",
-    "eslint": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.4.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "@vitest/coverage-v8": "4.0.18",
+    "eslint": "^10.0.3",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
+  },
+  "pnpm": {
+    "overrides": {
+      "rollup@>=4.0.0,<4.59.0": "4.59.0"
+    }
   }
 }

web/.husky/pre-commit

@@ -6,6 +6,20 @@ files=$(git diff --cached --name-only)
 
 api_modified=false
 web_modified=false
+skip_web_checks=false
+
+git_path() {
+    git rev-parse --git-path "$1"
+}
+
+if [ -f "$(git_path MERGE_HEAD)" ] || \
+   [ -f "$(git_path CHERRY_PICK_HEAD)" ] || \
+   [ -f "$(git_path REVERT_HEAD)" ] || \
+   [ -f "$(git_path SQUASH_MSG)" ] || \
+   [ -d "$(git_path rebase-merge)" ] || \
+   [ -d "$(git_path rebase-apply)" ]; then
+    skip_web_checks=true
+fi
 
 for file in $files
 do
@@ -43,6 +57,11 @@ if $api_modified; then
 fi
 
 if $web_modified; then
+    if $skip_web_checks; then
+        echo "Git operation in progress, skipping web checks"
+        exit 0
+    fi
+
     echo "Running ESLint on web module"
 
     if git diff --cached --quiet -- 'web/**/*.ts' 'web/**/*.tsx'; then

web/app/components/base/modern-monaco/init.ts

@@ -0,0 +1,25 @@
+import type { InitOptions } from 'modern-monaco'
+
+export const LIGHT_THEME_ID = 'light-plus'
+export const DARK_THEME_ID = 'dark-plus'
+
+const DEFAULT_INIT_OPTIONS: InitOptions = {
+  defaultTheme: DARK_THEME_ID,
+  themes: [
+    LIGHT_THEME_ID,
+    DARK_THEME_ID,
+  ],
+}
+
+let monacoInitPromise: Promise<typeof import('modern-monaco/editor-core') | null> | null = null
+
+export const initMonaco = async () => {
+  if (!monacoInitPromise) {
+    monacoInitPromise = (async () => {
+      const { init } = await import('modern-monaco')
+      return init(DEFAULT_INIT_OPTIONS)
+    })()
+  }
+
+  return monacoInitPromise
+}

web/app/components/base/modern-monaco/modern-monaco-editor.tsx

@@ -0,0 +1,250 @@
+'use client'
+
+import type { editor as MonacoEditor } from 'modern-monaco/editor-core'
+import type { FC } from 'react'
+import * as React from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import useTheme from '@/hooks/use-theme'
+import { Theme } from '@/types/app'
+import { cn } from '@/utils/classnames'
+import { DARK_THEME_ID, initMonaco, LIGHT_THEME_ID } from './init'
+
+type ModernMonacoEditorProps = {
+  value: string
+  language: string
+  readOnly?: boolean
+  options?: MonacoEditor.IEditorOptions
+  onChange?: (value: string) => void
+  onFocus?: () => void
+  onBlur?: () => void
+  onReady?: (editor: MonacoEditor.IStandaloneCodeEditor, monaco: typeof import('modern-monaco/editor-core')) => void
+  loading?: React.ReactNode
+  className?: string
+  style?: React.CSSProperties
+}
+
+type MonacoModule = typeof import('modern-monaco/editor-core')
+type EditorCallbacks = Pick<ModernMonacoEditorProps, 'onBlur' | 'onChange' | 'onFocus' | 'onReady'>
+type EditorSetup = {
+  editorOptions: MonacoEditor.IEditorOptions
+  language: string
+  resolvedTheme: string
+}
+
+const syncEditorValue = (
+  editor: MonacoEditor.IStandaloneCodeEditor,
+  monaco: MonacoModule,
+  model: MonacoEditor.ITextModel,
+  value: string,
+  preventTriggerChangeEventRef: React.RefObject<boolean>,
+) => {
+  const currentValue = model.getValue()
+  if (currentValue === value)
+    return
+
+  if (editor.getOption(monaco.editor.EditorOption.readOnly)) {
+    editor.setValue(value)
+    return
+  }
+
+  preventTriggerChangeEventRef.current = true
+  try {
+    editor.executeEdits('', [{
+      range: model.getFullModelRange(),
+      text: value,
+      forceMoveMarkers: true,
+    }])
+    editor.pushUndoStop()
+  }
+  finally {
+    preventTriggerChangeEventRef.current = false
+  }
+}
+
+const bindEditorCallbacks = (
+  editor: MonacoEditor.IStandaloneCodeEditor,
+  monaco: MonacoModule,
+  callbacksRef: React.RefObject<EditorCallbacks>,
+  preventTriggerChangeEventRef: React.RefObject<boolean>,
+) => {
+  const changeDisposable = editor.onDidChangeModelContent(() => {
+    if (preventTriggerChangeEventRef.current)
+      return
+    callbacksRef.current.onChange?.(editor.getValue())
+  })
+  const keydownDisposable = editor.onKeyDown((event) => {
+    const { key, code } = event.browserEvent
+    if (key === ' ' || code === 'Space')
+      event.stopPropagation()
+  })
+  const focusDisposable = editor.onDidFocusEditorText(() => {
+    callbacksRef.current.onFocus?.()
+  })
+  const blurDisposable = editor.onDidBlurEditorText(() => {
+    callbacksRef.current.onBlur?.()
+  })
+
+  return () => {
+    blurDisposable.dispose()
+    focusDisposable.dispose()
+    keydownDisposable.dispose()
+    changeDisposable.dispose()
+  }
+}
+
+export const ModernMonacoEditor: FC<ModernMonacoEditorProps> = ({
+  value,
+  language,
+  readOnly = false,
+  options,
+  onChange,
+  onFocus,
+  onBlur,
+  onReady,
+  loading,
+  className,
+  style,
+}) => {
+  const { theme: appTheme } = useTheme()
+  const resolvedTheme = appTheme === Theme.light ? LIGHT_THEME_ID : DARK_THEME_ID
+  const [isEditorReady, setIsEditorReady] = useState(false)
+  const containerRef = useRef<HTMLDivElement>(null)
+  const editorRef = useRef<MonacoEditor.IStandaloneCodeEditor | null>(null)
+  const modelRef = useRef<MonacoEditor.ITextModel | null>(null)
+  const monacoRef = useRef<MonacoModule | null>(null)
+  const preventTriggerChangeEventRef = useRef(false)
+  const valueRef = useRef(value)
+  const callbacksRef = useRef<EditorCallbacks>({ onChange, onFocus, onBlur, onReady })
+
+  const editorOptions = useMemo<MonacoEditor.IEditorOptions>(() => ({
+    automaticLayout: true,
+    readOnly,
+    domReadOnly: true,
+    minimap: { enabled: false },
+    wordWrap: 'on',
+    fixedOverflowWidgets: true,
+    tabFocusMode: false,
+    ...options,
+  }), [readOnly, options])
+  const setupRef = useRef<EditorSetup>({
+    editorOptions,
+    language,
+    resolvedTheme,
+  })
+
+  useEffect(() => {
+    valueRef.current = value
+  }, [value])
+
+  useEffect(() => {
+    callbacksRef.current = { onChange, onFocus, onBlur, onReady }
+  }, [onChange, onFocus, onBlur, onReady])
+
+  useEffect(() => {
+    setupRef.current = {
+      editorOptions,
+      language,
+      resolvedTheme,
+    }
+  }, [editorOptions, language, resolvedTheme])
+
+  useEffect(() => {
+    let disposed = false
+    let cleanup: (() => void) | undefined
+
+    const setup = async () => {
+      const monaco = await initMonaco()
+      if (!monaco || disposed || !containerRef.current)
+        return
+
+      monacoRef.current = monaco
+
+      const editor = monaco.editor.create(containerRef.current, setupRef.current.editorOptions)
+      editorRef.current = editor
+
+      const model = monaco.editor.createModel(valueRef.current, setupRef.current.language)
+      modelRef.current = model
+
+      editor.setModel(model)
+
+      monaco.editor.setTheme(setupRef.current.resolvedTheme)
+
+      const disposeCallbacks = bindEditorCallbacks(
+        editor,
+        monaco,
+        callbacksRef,
+        preventTriggerChangeEventRef,
+      )
+      const resizeObserver = new ResizeObserver(() => {
+        editor.layout()
+      })
+      resizeObserver.observe(containerRef.current)
+      callbacksRef.current.onReady?.(editor, monaco)
+      setIsEditorReady(true)
+
+      cleanup = () => {
+        resizeObserver.disconnect()
+        disposeCallbacks()
+        editor.dispose()
+        model.dispose()
+        setIsEditorReady(false)
+      }
+    }
+
+    setup()
+
+    return () => {
+      disposed = true
+      cleanup?.()
+    }
+  }, [])
+
+  useEffect(() => {
+    const editor = editorRef.current
+    if (!editor)
+      return
+    editor.updateOptions(editorOptions)
+  }, [editorOptions])
+
+  useEffect(() => {
+    const monaco = monacoRef.current
+    const model = modelRef.current
+    if (!monaco || !model)
+      return
+    monaco.editor.setModelLanguage(model, language)
+  }, [language])
+
+  useEffect(() => {
+    const monaco = monacoRef.current
+    if (!monaco)
+      return
+    monaco.editor.setTheme(resolvedTheme)
+  }, [resolvedTheme])
+
+  useEffect(() => {
+    const editor = editorRef.current
+    const monaco = monacoRef.current
+    const model = modelRef.current
+    if (!editor || !monaco || !model)
+      return
+
+    syncEditorValue(editor, monaco, model, value, preventTriggerChangeEventRef)
+  }, [value])
+
+  return (
+    <div
+      className={cn('relative h-full w-full', className)}
+      style={style}
+    >
+      <div
+        ref={containerRef}
+        className="h-full w-full"
+      />
+      {!isEditorReady && !!loading && (
+        <div className="absolute inset-0 flex items-center justify-center">
+          {loading}
+        </div>
+      )}
+    </div>
+  )
+}

web/app/components/base/ui/select/__tests__/index.spec.tsx

@@ -3,16 +3,18 @@ import { describe, expect, it, vi } from 'vitest'
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../index'
 
 const renderOpenSelect = ({
+  rootProps = {},
   triggerProps = {},
   contentProps = {},
   onValueChange,
 }: {
+  rootProps?: Record<string, unknown>
   triggerProps?: Record<string, unknown>
   contentProps?: Record<string, unknown>
   onValueChange?: (value: string | null) => void
 } = {}) => {
   return render(
-    <Select open defaultValue="seattle" onValueChange={onValueChange}>
+    <Select open defaultValue="seattle" onValueChange={onValueChange} {...rootProps}>
       <SelectTrigger aria-label="city select" {...triggerProps}>
         <SelectValue />
       </SelectTrigger>
@@ -109,6 +111,107 @@ describe('Select wrappers', () => {
       const clearButton = screen.getByRole('button', { name: /clear selection/i })
       expect(() => fireEvent.click(clearButton)).not.toThrow()
     })
+
+    it('should apply regular size variant classes by default', () => {
+      renderOpenSelect()
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toMatch(/system-sm-regular/)
+      expect(trigger.className).toMatch(/rounded-lg/)
+    })
+
+    it('should apply small size variant classes when size is small', () => {
+      renderOpenSelect({
+        triggerProps: { size: 'small' },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toMatch(/system-xs-regular/)
+      expect(trigger.className).toMatch(/rounded-md/)
+    })
+
+    it('should apply large size variant classes when size is large', () => {
+      renderOpenSelect({
+        triggerProps: { size: 'large' },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toMatch(/system-md-regular/)
+    })
+
+    it('should apply disabled styling via data attributes when disabled', () => {
+      renderOpenSelect({
+        triggerProps: { disabled: true },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger).toHaveAttribute('data-disabled')
+      expect(trigger.className).toContain('data-[disabled]:bg-components-input-bg-disabled')
+    })
+
+    it('should apply disabled placeholder color class for compound state', () => {
+      renderOpenSelect({
+        triggerProps: { disabled: true },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toContain('data-[disabled]:data-[placeholder]:text-components-input-text-disabled')
+    })
+
+    it('should show error icon and apply destructive styling when variant is destructive', () => {
+      renderOpenSelect({
+        triggerProps: { variant: 'destructive' },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toContain('border-components-input-border-destructive')
+      expect(trigger.className).toContain('bg-components-input-bg-destructive')
+      const errorIcon = trigger.querySelector('.i-ri-error-warning-line')
+      expect(errorIcon).toBeInTheDocument()
+    })
+
+    it('should hide clear button when variant is destructive even if clearable', () => {
+      renderOpenSelect({
+        triggerProps: { clearable: true, variant: 'destructive' },
+      })
+
+      expect(screen.queryByRole('button', { name: /clear selection/i })).not.toBeInTheDocument()
+    })
+
+    it('should apply readonly styling via data attributes when Root is readOnly', () => {
+      renderOpenSelect({
+        rootProps: { readOnly: true },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger).toHaveAttribute('data-readonly')
+      expect(trigger.className).toContain('data-[readonly]:bg-transparent')
+    })
+
+    it('should hide arrow icon via CSS when Root is readOnly', () => {
+      renderOpenSelect({
+        rootProps: { readOnly: true },
+      })
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      const iconWrapper = trigger.querySelector('[class*="group-data-[readonly]:hidden"]')
+      expect(iconWrapper).toBeInTheDocument()
+    })
+
+    it('should set aria-hidden on decorative icons', () => {
+      renderOpenSelect()
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      const arrowIcon = trigger.querySelector('.i-ri-arrow-down-s-line')
+      expect(arrowIcon).toHaveAttribute('aria-hidden', 'true')
+    })
+
+    it('should include placeholder color class via data attribute', () => {
+      renderOpenSelect()
+
+      const trigger = screen.getByRole('combobox', { name: 'city select' })
+      expect(trigger.className).toContain('data-[placeholder]:text-components-input-text-placeholder')
+    })
   })
 
   describe('SelectContent', () => {

web/app/components/base/ui/select/index.tsx

@@ -1,7 +1,9 @@
 'use client'
 
+import type { VariantProps } from 'class-variance-authority'
 import type { Placement } from '@/app/components/base/ui/placement'
 import { Select as BaseSelect } from '@base-ui/react/select'
+import { cva } from 'class-variance-authority'
 import * as React from 'react'
 import { parsePlacement } from '@/app/components/base/ui/placement'
 import { cn } from '@/utils/classnames'
@@ -12,61 +14,110 @@ export const SelectGroup = BaseSelect.Group
 export const SelectGroupLabel = BaseSelect.GroupLabel
 export const SelectSeparator = BaseSelect.Separator
 
+export const selectTriggerVariants = cva(
+  '',
+  {
+    variants: {
+      size: {
+        small: 'h-6 gap-px rounded-md px-[5px] py-0 system-xs-regular',
+        regular: 'h-8 gap-0.5 rounded-lg px-2 py-1 system-sm-regular',
+        large: 'h-9 gap-0.5 rounded-[10px] px-2.5 py-1 system-md-regular',
+      },
+      variant: {
+        default: '',
+        destructive: 'border border-components-input-border-destructive bg-components-input-bg-destructive shadow-xs hover:border-components-input-border-destructive hover:bg-components-input-bg-destructive',
+      },
+    },
+    defaultVariants: {
+      size: 'regular',
+      variant: 'default',
+    },
+  },
+)
+
+const contentPadding: Record<string, string> = {
+  small: 'px-[3px] py-1',
+  regular: 'p-1',
+  large: 'px-1.5 py-1',
+}
+
 type SelectTriggerProps = React.ComponentPropsWithoutRef<typeof BaseSelect.Trigger> & {
   clearable?: boolean
   onClear?: () => void
   loading?: boolean
-}
+} & VariantProps<typeof selectTriggerVariants>
 
 export function SelectTrigger({
   className,
   children,
+  size = 'regular',
+  variant = 'default',
   clearable = false,
   onClear,
   loading = false,
   ...props
 }: SelectTriggerProps) {
-  const showClear = clearable && !loading
+  const paddingClass = contentPadding[size ?? 'regular']
+  const isDestructive = variant === 'destructive'
+
+  let trailingIcon: React.ReactNode = null
+  if (loading) {
+    trailingIcon = (
+      <span className="shrink-0 text-text-quaternary" aria-hidden="true">
+        <span className="i-ri-loader-4-line h-3.5 w-3.5 animate-spin" />
+      </span>
+    )
+  }
+  else if (isDestructive) {
+    trailingIcon = (
+      <span className="shrink-0 text-text-destructive-secondary" aria-hidden="true">
+        <span className="i-ri-error-warning-line h-4 w-4" />
+      </span>
+    )
+  }
+  else if (clearable) {
+    trailingIcon = (
+      <span
+        role="button"
+        aria-label="Clear selection"
+        tabIndex={-1}
+        className="shrink-0 cursor-pointer text-text-quaternary hover:text-text-secondary group-data-[disabled]:hidden group-data-[readonly]:hidden"
+        onClick={(e) => {
+          e.stopPropagation()
+          onClear?.()
+        }}
+        onMouseDown={e => e.stopPropagation()}
+      >
+        <span className="i-ri-close-circle-fill h-3.5 w-3.5" aria-hidden="true" />
+      </span>
+    )
+  }
+  else {
+    trailingIcon = (
+      <BaseSelect.Icon className="shrink-0 text-text-quaternary transition-colors group-hover:text-text-secondary data-[open]:text-text-secondary group-data-[readonly]:hidden">
+        <span className="i-ri-arrow-down-s-line h-4 w-4" aria-hidden="true" />
+      </BaseSelect.Icon>
+    )
+  }
 
   return (
     <BaseSelect.Trigger
       className={cn(
-        'group relative flex h-8 w-full items-center rounded-lg border-0 bg-components-input-bg-normal px-2 text-left text-components-input-text-filled outline-none',
-        'hover:bg-state-base-hover-alt focus-visible:bg-state-base-hover-alt disabled:cursor-not-allowed disabled:opacity-50',
+        'group relative flex w-full items-center border-0 bg-components-input-bg-normal text-left text-components-input-text-filled outline-none',
+        'hover:bg-state-base-hover-alt focus-visible:bg-state-base-hover-alt',
+        'data-[placeholder]:text-components-input-text-placeholder',
+        selectTriggerVariants({ size, variant }),
+        'data-[readonly]:cursor-default data-[readonly]:bg-transparent data-[readonly]:hover:bg-transparent',
+        'data-[disabled]:cursor-not-allowed data-[disabled]:bg-components-input-bg-disabled data-[disabled]:text-components-input-text-filled-disabled data-[disabled]:hover:bg-components-input-bg-disabled',
+        'data-[disabled]:data-[placeholder]:text-components-input-text-disabled',
         className,
       )}
       {...props}
     >
-      <span className="grow truncate">{children}</span>
-      {loading
-        ? (
-            <span className="ml-1 shrink-0 text-text-quaternary">
-              <span className="i-ri-loader-4-line h-3.5 w-3.5 animate-spin" />
-            </span>
-          )
-        : showClear
-          ? (
-              <span
-                role="button"
-                aria-label="Clear selection"
-                tabIndex={-1}
-                className="ml-1 shrink-0 cursor-pointer text-text-quaternary hover:text-text-secondary"
-                onClick={(e) => {
-                  e.stopPropagation()
-                  onClear?.()
-                }}
-                onMouseDown={(e) => {
-                  e.stopPropagation()
-                }}
-              >
-                <span className="i-ri-close-circle-fill h-3.5 w-3.5" />
-              </span>
-            )
-          : (
-              <BaseSelect.Icon className="ml-1 shrink-0 text-text-quaternary transition-colors group-hover:text-text-secondary data-[open]:text-text-secondary">
-                <span className="i-ri-arrow-down-s-line h-4 w-4" />
-              </BaseSelect.Icon>
-            )}
+      <span className={cn('min-w-0 grow truncate', paddingClass)}>
+        {children}
+      </span>
+      {trailingIcon}
     </BaseSelect.Trigger>
   )
 }
@@ -152,11 +203,11 @@ export function SelectItem({
       )}
       {...props}
     >
-      <BaseSelect.ItemText className="mr-1 grow truncate px-1">
+      <BaseSelect.ItemText className="mr-1 min-w-0 grow truncate px-1">
         {children}
       </BaseSelect.ItemText>
       <BaseSelect.ItemIndicator className="flex shrink-0 items-center text-text-accent">
-        <span className="i-ri-check-line h-4 w-4" />
+        <span className="i-ri-check-line h-4 w-4" aria-hidden="true" />
       </BaseSelect.ItemIndicator>
     </BaseSelect.Item>
   )

web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx

@@ -1,24 +1,18 @@
 'use client'
 import type { FC } from 'react'
-import Editor, { loader } from '@monaco-editor/react'
 import { noop } from 'es-toolkit/function'
 import * as React from 'react'
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useMemo, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
 import {
   getFilesInLogs,
 } from '@/app/components/base/file-uploader/utils'
+import { ModernMonacoEditor } from '@/app/components/base/modern-monaco/modern-monaco-editor'
 import { CodeLanguage } from '@/app/components/workflow/nodes/code/types'
-import useTheme from '@/hooks/use-theme'
-import { Theme } from '@/types/app'
 import { cn } from '@/utils/classnames'
-import { basePath } from '@/utils/var'
 import Base from '../base'
 import './style.css'
 
-// load file from local instead of cdn https://github.com/suren-atoyan/monaco-react/issues/482
-if (typeof window !== 'undefined')
-  loader.config({ paths: { vs: `${window.location.origin}${basePath}/vs` } })
-
 const CODE_EDITOR_LINE_HEIGHT = 18
 
 export type Props = {
@@ -72,15 +66,10 @@ const CodeEditor: FC<Props> = ({
   tip,
   footer,
 }) => {
+  const { t } = useTranslation()
   const [isFocus, setIsFocus] = React.useState(false)
-  const [isMounted, setIsMounted] = React.useState(false)
   const minHeight = height || 200
   const [editorContentHeight, setEditorContentHeight] = useState(56)
-  const { theme: appTheme } = useTheme()
-  const valueRef = useRef(value)
-  useEffect(() => {
-    valueRef.current = value
-  }, [value])
 
   const fileList = useMemo(() => {
     if (typeof value === 'object')
@@ -106,18 +95,15 @@ const CodeEditor: FC<Props> = ({
   const handleEditorDidMount = (editor: any, monaco: any) => {
     editorRef.current = editor
     resizeEditorToContent()
-
-    editor.onDidFocusEditorText(() => {
-      setIsFocus(true)
-    })
-    editor.onDidBlurEditorText(() => {
-      setIsFocus(false)
-    })
-
-    monaco.editor.setTheme(appTheme === Theme.light ? 'light' : 'vs-dark') // Fix: sometimes not load the default theme
-
     onMount?.(editor, monaco)
-    setIsMounted(true)
+  }
+
+  const handleEditorFocus = () => {
+    setIsFocus(true)
+  }
+
+  const handleEditorBlur = () => {
+    setIsFocus(false)
   }
 
   const outPutValue = (() => {
@@ -131,31 +117,23 @@ const CodeEditor: FC<Props> = ({
     }
   })()
 
-  const theme = useMemo(() => {
-    if (appTheme === Theme.light)
-      return 'light'
-    return 'vs-dark'
-  }, [appTheme])
-
   const main = (
     <>
-      {/* https://www.npmjs.com/package/@monaco-editor/react */}
-      <Editor
+      <ModernMonacoEditor
         // className='min-h-[100%]' // h-full
         // language={language === CodeLanguage.javascript ? 'javascript' : 'python'}
         language={languageMap[language] || 'javascript'}
-        theme={isMounted ? theme : 'default-theme'} // sometimes not load the default theme
         value={outPutValue}
-        loading={<span className="text-text-primary">Loading...</span>}
+        readOnly={readOnly}
         onChange={handleEditorChange}
+        onFocus={handleEditorFocus}
+        onBlur={handleEditorBlur}
+        onReady={handleEditorDidMount}
+        loading={<span className="text-text-primary">{t('loading', { ns: 'common' })}</span>}
         // https://microsoft.github.io/monaco-editor/typedoc/interfaces/editor.IEditorOptions.html
         options={{
-          readOnly,
-          domReadOnly: true,
           quickSuggestions: false,
-          minimap: { enabled: false },
           lineNumbersMinChars: 1, // would change line num width
-          wordWrap: 'on', // auto line wrap
           // lineNumbers: (num) => {
           //   return <div>{num}</div>
           // }
@@ -165,7 +143,6 @@ const CodeEditor: FC<Props> = ({
           },
           stickyScroll: { enabled: false },
         }}
-        onMount={handleEditorDidMount}
       />
       {!outPutValue && !isFocus && <div className="pointer-events-none absolute left-[36px] top-0 text-[13px] font-normal leading-[18px] text-components-input-text-placeholder">{placeholder}</div>}
     </>

web/app/components/workflow/nodes/llm/components/json-schema-config-modal/code-editor.tsx

@@ -1,13 +1,11 @@
 import type { FC } from 'react'
-import { Editor } from '@monaco-editor/react'
 import { RiClipboardLine, RiIndentIncrease } from '@remixicon/react'
 import copy from 'copy-to-clipboard'
 import * as React from 'react'
-import { useCallback, useEffect, useMemo, useRef } from 'react'
+import { useCallback, useRef } from 'react'
 import { useTranslation } from 'react-i18next'
+import { ModernMonacoEditor } from '@/app/components/base/modern-monaco/modern-monaco-editor'
 import Tooltip from '@/app/components/base/tooltip'
-import useTheme from '@/hooks/use-theme'
-import { Theme } from '@/types/app'
 import { cn } from '@/utils/classnames'
 
 type CodeEditorProps = {
@@ -35,54 +33,11 @@ const CodeEditor: FC<CodeEditorProps> = ({
   onBlur,
 }) => {
   const { t } = useTranslation()
-  const { theme } = useTheme()
-  const monacoRef = useRef<any>(null)
   const editorRef = useRef<any>(null)
-  const [isMounted, setIsMounted] = React.useState(false)
-  const containerRef = useRef<HTMLDivElement>(null)
 
-  useEffect(() => {
-    if (monacoRef.current) {
-      if (theme === Theme.light)
-        monacoRef.current.editor.setTheme('light-theme')
-      else
-        monacoRef.current.editor.setTheme('dark-theme')
-    }
-  }, [theme])
-
-  const handleEditorDidMount = useCallback((editor: any, monaco: any) => {
+  const handleEditorReady = useCallback((editor: any) => {
     editorRef.current = editor
-    monacoRef.current = monaco
-
-    editor.onDidFocusEditorText(() => {
-      onFocus?.()
-    })
-    editor.onDidBlurEditorText(() => {
-      onBlur?.()
-    })
-
-    monaco.editor.defineTheme('light-theme', {
-      base: 'vs',
-      inherit: true,
-      rules: [],
-      colors: {
-        'editor.background': '#00000000',
-        'editor.lineHighlightBackground': '#00000000',
-        'focusBorder': '#00000000',
-      },
-    })
-    monaco.editor.defineTheme('dark-theme', {
-      base: 'vs-dark',
-      inherit: true,
-      rules: [],
-      colors: {
-        'editor.background': '#00000000',
-        'editor.lineHighlightBackground': '#00000000',
-        'focusBorder': '#00000000',
-      },
-    })
-    monaco.editor.setTheme('light-theme')
-    setIsMounted(true)
+    editor.getModel()?.updateOptions({ tabSize: 2 })
   }, [])
 
   const formatJsonContent = useCallback(() => {
@@ -95,29 +50,11 @@ const CodeEditor: FC<CodeEditorProps> = ({
       onUpdate?.(value)
   }, [onUpdate])
 
-  const editorTheme = useMemo(() => {
-    if (theme === Theme.light)
-      return 'light-theme'
-    return 'dark-theme'
-  }, [theme])
-  useEffect(() => {
-    const resizeObserver = new ResizeObserver(() => {
-      editorRef.current?.layout()
-    })
-
-    if (containerRef.current)
-      resizeObserver.observe(containerRef.current)
-
-    return () => {
-      resizeObserver.disconnect()
-    }
-  }, [])
-
   return (
     <div className={cn('flex h-full flex-col overflow-hidden bg-components-input-bg-normal', hideTopMenu && 'pt-2', className)}>
       {!hideTopMenu && (
         <div className="flex items-center justify-between pl-2 pr-1 pt-1">
-          <div className="system-xs-semibold-uppercase py-0.5 text-text-secondary">
+          <div className="py-0.5 text-text-secondary system-xs-semibold-uppercase">
             <span className="px-1 py-0.5">JSON</span>
           </div>
           <div className="flex items-center gap-x-0.5">
@@ -146,19 +83,17 @@ const CodeEditor: FC<CodeEditorProps> = ({
       )}
       {topContent}
       <div className={cn('relative overflow-hidden', editorWrapperClassName)}>
-        <Editor
-          defaultLanguage="json"
-          theme={isMounted ? editorTheme : 'default-theme'} // sometimes not load the default theme
+        <ModernMonacoEditor
+          language="json"
           value={value}
+          readOnly={readOnly}
           onChange={handleEditorChange}
-          onMount={handleEditorDidMount}
+          onReady={handleEditorReady}
+          onFocus={onFocus}
+          onBlur={onBlur}
+          loading={<span className="text-text-primary">{t('loading', { ns: 'common' })}</span>}
           options={{
-            readOnly,
-            domReadOnly: true,
-            minimap: { enabled: false },
-            tabSize: 2,
             scrollBeyondLastLine: false,
-            wordWrap: 'on',
             wrappingIndent: 'same',
             overviewRulerBorder: false,
             hideCursorInOverviewRuler: true,

web/app/components/workflow/utils/__tests__/common.spec.ts

@@ -146,6 +146,16 @@ describe('isEventTargetInputArea', () => {
     expect(isEventTargetInputArea(el)).toBe(true)
   })
 
+  it('should return true for monaco editor descendants', () => {
+    const wrapper = document.createElement('div')
+    wrapper.className = 'monaco-editor'
+    const child = document.createElement('div')
+    wrapper.appendChild(child)
+    document.body.appendChild(wrapper)
+    expect(isEventTargetInputArea(child)).toBe(true)
+    wrapper.remove()
+  })
+
   it('should return undefined for non-input elements', () => {
     const el = document.createElement('div')
     expect(isEventTargetInputArea(el)).toBeUndefined()

web/app/components/workflow/utils/common.ts

@@ -32,6 +32,9 @@ export const isEventTargetInputArea = (target: HTMLElement) => {
 
   if (target.contentEditable === 'true')
     return true
+
+  if (target.closest?.('.monaco-editor, .monaco-diff-editor'))
+    return true
 }
 
 /**

web/eslint-suppressions.json

@@ -7666,11 +7666,8 @@
     "no-restricted-imports": {
       "count": 1
     },
-    "tailwindcss/enforce-consistent-class-order": {
-      "count": 1
-    },
     "ts/no-explicit-any": {
-      "count": 4
+      "count": 2
     }
   },
   "app/components/workflow/nodes/llm/components/json-schema-config-modal/error-message.tsx": {

web/package.json

@@ -73,7 +73,6 @@
     "@lexical/selection": "0.41.0",
     "@lexical/text": "0.41.0",
     "@lexical/utils": "0.41.0",
-    "@monaco-editor/react": "4.7.0",
     "@octokit/core": "7.0.6",
     "@octokit/request-error": "7.1.0",
     "@orpc/client": "1.13.6",
@@ -124,6 +123,7 @@
     "mermaid": "11.13.0",
     "mime": "4.1.0",
     "mitt": "3.0.1",
+    "modern-monaco": "0.4.0",
     "negotiator": "1.0.0",
     "next": "16.1.6",
     "next-themes": "0.4.6",
@@ -245,7 +245,6 @@
   "pnpm": {
     "overrides": {
       "@lexical/code": "npm:lexical-code-no-prism@0.41.0",
-      "@monaco-editor/loader": "1.7.0",
       "@nolyfill/safe-buffer": "npm:safe-buffer@^5.2.1",
       "array-includes": "npm:@nolyfill/array-includes@^1.0.44",
       "array.prototype.findlast": "npm:@nolyfill/array.prototype.findlast@^1.0.44",
@@ -257,6 +256,7 @@
       "brace-expansion@<2.0.2": "2.0.2",
       "canvas": "^3.2.1",
       "devalue@<5.3.2": "5.3.2",
+      "dompurify@>=3.1.3,<=3.3.1": "3.3.2",
       "es-iterator-helpers": "npm:@nolyfill/es-iterator-helpers@^1.0.21",
       "esbuild@<0.27.2": "0.27.2",
       "glob@>=10.2.0,<10.5.0": "11.1.0",
@@ -275,6 +275,7 @@
       "pbkdf2@<3.1.3": "3.1.3",
       "prismjs": "~1.30",
       "prismjs@<1.30.0": "1.30.0",
+      "rollup@>=4.0.0,<4.59.0": "4.59.0",
       "safe-buffer": "^5.2.1",
       "safe-regex-test": "npm:@nolyfill/safe-regex-test@^1.0.44",
       "safer-buffer": "npm:@nolyfill/safer-buffer@^1.0.44",
@@ -285,6 +286,8 @@
       "string.prototype.matchall": "npm:@nolyfill/string.prototype.matchall@^1.0.44",
       "string.prototype.repeat": "npm:@nolyfill/string.prototype.repeat@^1.0.44",
       "string.prototype.trimend": "npm:@nolyfill/string.prototype.trimend@^1.0.44",
+      "svgo@>=3.0.0,<3.3.3": "3.3.3",
+      "tar@<=7.5.10": "7.5.11",
       "typed-array-buffer": "npm:@nolyfill/typed-array-buffer@^1.0.44",
       "which-typed-array": "npm:@nolyfill/which-typed-array@^1.0.44"
     },

web/public/vs/basic-languages/apex/apex.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/apex/apex", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var i=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var d=(e,t)=>{for(var s in t)i(e,s,{get:t[s],enumerable:!0})},g=(e,t,s,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of c(t))!l.call(e,o)&&o!==s&&i(e,o,{get:()=>t[o],enumerable:!(a=r(t,o))||a.enumerable});return e};var p=e=>g(i({},"__esModule",{value:!0}),e);var h={};d(h,{conf:()=>m,language:()=>b});var m={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}],folding:{markers:{start:new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),end:new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")}}},u=["abstract","activate","and","any","array","as","asc","assert","autonomous","begin","bigdecimal","blob","boolean","break","bulk","by","case","cast","catch","char","class","collect","commit","const","continue","convertcurrency","decimal","default","delete","desc","do","double","else","end","enum","exception","exit","export","extends","false","final","finally","float","for","from","future","get","global","goto","group","having","hint","if","implements","import","in","inner","insert","instanceof","int","interface","into","join","last_90_days","last_month","last_n_days","last_week","like","limit","list","long","loop","map","merge","native","new","next_90_days","next_month","next_n_days","next_week","not","null","nulls","number","object","of","on","or","outer","override","package","parallel","pragma","private","protected","public","retrieve","return","returning","rollback","savepoint","search","select","set","short","sort","stat","static","strictfp","super","switch","synchronized","system","testmethod","then","this","this_month","this_week","throw","throws","today","tolabel","tomorrow","transaction","transient","trigger","true","try","type","undelete","update","upsert","using","virtual","void","volatile","webservice","when","where","while","yesterday"],f=e=>e.charAt(0).toUpperCase()+e.substr(1),n=[];u.forEach(e=>{n.push(e),n.push(e.toUpperCase()),n.push(f(e))});var b={defaultToken:"",tokenPostfix:".apex",keywords:n,operators:["=",">","<","!","~","?",":","==","<=",">=","!=","&&","||","++","--","+","-","*","/","&","|","^","%","<<",">>",">>>","+=","-=","*=","/=","&=","|=","^=","%=","<<=",">>=",">>>="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,tokenizer:{root:[[/[a-z_$][\w$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],[/[A-Z][\w\$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"type.identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,"annotation"],[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)[fFdD]/,"number.float"],[/(@digits)[lL]?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string",'@string."'],[/'/,"string","@string.'"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@apexdoc"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],apexdoc:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"']+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]]}};return p(h);})();
-return moduleExports;
-});

web/public/vs/basic-languages/azcli/azcli.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/azcli/azcli", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},k=(t,e,o,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of r(e))!l.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(a=i(e,n))||a.enumerable});return t};var p=t=>k(s({},"__esModule",{value:!0}),t);var d={};c(d,{conf:()=>f,language:()=>g});var f={comments:{lineComment:"#"}},g={defaultToken:"keyword",ignoreCase:!0,tokenPostfix:".azcli",str:/[^#\s]/,tokenizer:{root:[{include:"@comment"},[/\s-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}],[/^-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}]],type:[{include:"@comment"},[/-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":"key.identifier"}}],[/@str+\s*/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}]],comment:[[/#.*$/,{cases:{"@eos":{token:"comment",next:"@popall"}}}]]}};return p(d);})();
-return moduleExports;
-});

web/public/vs/basic-languages/bat/bat.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/bat/bat", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var n=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var g=(o,e)=>{for(var t in e)n(o,t,{get:e[t],enumerable:!0})},c=(o,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of l(e))!i.call(o,s)&&s!==t&&n(o,s,{get:()=>e[s],enumerable:!(a=r(e,s))||a.enumerable});return o};var p=o=>c(n({},"__esModule",{value:!0}),o);var k={};g(k,{conf:()=>d,language:()=>m});var d={comments:{lineComment:"REM"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],folding:{markers:{start:new RegExp("^\\s*(::\\s*|REM\\s+)#region"),end:new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")}}},m={defaultToken:"",ignoreCase:!0,tokenPostfix:".bat",brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"}],keywords:/call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,symbols:/[=><!~?&|+\-*\/\^;\.,]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/^(\s*)(rem(?:\s.*|))$/,["","comment"]],[/(\@?)(@keywords)(?!\w)/,[{token:"keyword"},{token:"keyword.$2"}]],[/[ \t\r\n]+/,""],[/setlocal(?!\w)/,"keyword.tag-setlocal"],[/endlocal(?!\w)/,"keyword.tag-setlocal"],[/[a-zA-Z_]\w*/,""],[/:\w*/,"metatag"],[/%[^%]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/"/,"string",'@string."'],[/'/,"string","@string.'"]],string:[[/[^\\"'%]+/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/%[\w ]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/$/,"string","@popall"]]}};return p(k);})();
-return moduleExports;
-});

web/public/vs/basic-languages/bicep/bicep.js

@@ -1,11 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/bicep/bicep", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var o in n)r(e,o,{get:n[o],enumerable:!0})},l=(e,n,o,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of c(n))!a.call(e,t)&&t!==o&&r(e,t,{get:()=>n[t],enumerable:!(i=s(n,t))||i.enumerable});return e};var m=e=>l(r({},"__esModule",{value:!0}),e);var y={};g(y,{conf:()=>$,language:()=>w});var p=e=>`\\b${e}\\b`,k="[_a-zA-Z]",x="[_a-zA-Z0-9]",u=p(`${k}${x}*`),d=["targetScope","resource","module","param","var","output","for","in","if","existing"],b=["true","false","null"],f="[ \\t\\r\\n]",C="[0-9]+",$={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'"},{open:"'''",close:"'''"}],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:"'''",close:"'''",notIn:["string","comment"]}],autoCloseBefore:`:.,=}])' 
-	`,indentationRules:{increaseIndentPattern:new RegExp("^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$"),decreaseIndentPattern:new RegExp("^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$")}},w={defaultToken:"",tokenPostfix:".bicep",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"}],symbols:/[=><!~?:&|+\-*/^%]+/,keywords:d,namedLiterals:b,escapes:"\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|'|\\${)",tokenizer:{root:[{include:"@expression"},{include:"@whitespace"}],stringVerbatim:[{regex:"(|'|'')[^']",action:{token:"string"}},{regex:"'''",action:{token:"string.quote",next:"@pop"}}],stringLiteral:[{regex:"\\${",action:{token:"delimiter.bracket",next:"@bracketCounting"}},{regex:"[^\\\\'$]+",action:{token:"string"}},{regex:"@escapes",action:{token:"string.escape"}},{regex:"\\\\.",action:{token:"string.escape.invalid"}},{regex:"'",action:{token:"string",next:"@pop"}}],bracketCounting:[{regex:"{",action:{token:"delimiter.bracket",next:"@bracketCounting"}},{regex:"}",action:{token:"delimiter.bracket",next:"@pop"}},{include:"expression"}],comment:[{regex:"[^\\*]+",action:{token:"comment"}},{regex:"\\*\\/",action:{token:"comment",next:"@pop"}},{regex:"[\\/*]",action:{token:"comment"}}],whitespace:[{regex:f},{regex:"\\/\\*",action:{token:"comment",next:"@comment"}},{regex:"\\/\\/.*$",action:{token:"comment"}}],expression:[{regex:"'''",action:{token:"string.quote",next:"@stringVerbatim"}},{regex:"'",action:{token:"string.quote",next:"@stringLiteral"}},{regex:C,action:{token:"number"}},{regex:u,action:{cases:{"@keywords":{token:"keyword"},"@namedLiterals":{token:"keyword"},"@default":{token:"identifier"}}}}]}};return m(y);})();
-return moduleExports;
-});

web/public/vs/basic-languages/cameligo/cameligo.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/cameligo/cameligo", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var n in e)s(o,n,{get:e[n],enumerable:!0})},m=(o,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!l.call(o,t)&&t!==n&&s(o,t,{get:()=>e[t],enumerable:!(r=i(e,t))||r.enumerable});return o};var p=o=>m(s({},"__esModule",{value:!0}),o);var u={};c(u,{conf:()=>d,language:()=>g});var d={comments:{lineComment:"//",blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"],["<",">"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'},{open:"(*",close:"*)"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'},{open:"(*",close:"*)"}]},g={defaultToken:"",tokenPostfix:".cameligo",ignoreCase:!0,brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["abs","assert","block","Bytes","case","Crypto","Current","else","failwith","false","for","fun","if","in","let","let%entry","let%init","List","list","Map","map","match","match%nat","mod","not","operation","Operation","of","record","Set","set","sender","skip","source","String","then","to","true","type","with"],typeKeywords:["int","unit","string","tz","nat","bool"],operators:["=",">","<","<=",">=","<>",":",":=","and","mod","or","+","-","*","/","@","&","^","%","->","<-","&&","||"],symbols:/[=><:@\^&|+\-*\/\^%]+/,tokenizer:{root:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\$[0-9a-fA-F]{1,16}/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/'/,"string","@string"],[/'[^\\']'/,"string"],[/'/,"string.invalid"],[/\#\d+/,"string"]],comment:[[/[^\(\*]+/,"comment"],[/\*\)/,"comment","@pop"],[/\(\*/,"comment"]],string:[[/[^\\']+/,"string"],[/\\./,"string.escape.invalid"],[/'/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"],[/\(\*/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/coffee/coffee.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/coffee/coffee", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var l=(n,e)=>{for(var t in e)s(n,t,{get:e[t],enumerable:!0})},p=(n,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of g(e))!a.call(n,r)&&r!==t&&s(n,r,{get:()=>e[r],enumerable:!(o=i(e,r))||o.enumerable});return n};var c=n=>p(s({},"__esModule",{value:!0}),n);var m={};l(m,{conf:()=>d,language:()=>x});var d={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{blockComment:["###","###"],lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},x={defaultToken:"",ignoreCase:!0,tokenPostfix:".coffee",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"}],regEx:/\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,keywords:["and","or","is","isnt","not","on","yes","@","no","off","true","false","null","this","new","delete","typeof","in","instanceof","return","throw","break","continue","debugger","if","else","switch","for","while","do","try","catch","finally","class","extends","super","undefined","then","unless","until","loop","of","by","when"],symbols:/[=><!~?&%|+\-*\/\^\.,\:]+/,escapes:/\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/\@[a-zA-Z_]\w*/,"variable.predefined"],[/[a-zA-Z_]\w*/,{cases:{this:"variable.predefined","@keywords":{token:"keyword.$0"},"@default":""}}],[/[ \t\r\n]+/,""],[/###/,"comment","@comment"],[/#.*$/,"comment"],["///",{token:"regexp",next:"@hereregexp"}],[/^(\s*)(@regEx)/,["","regexp"]],[/(\()(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\,)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\=)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\:)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\[)(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\!)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\&)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\|)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\?)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\{)(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\;)(\s*)(@regEx)/,["","","regexp"]],[/}/,{cases:{"$S2==interpolatedstring":{token:"string",next:"@pop"},"@default":"@brackets"}}],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d+\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F]+/,"number.hex"],[/0[0-7]+(?!\d)/,"number.octal"],[/\d+/,"number"],[/[,.]/,"delimiter"],[/"""/,"string",'@herestring."""'],[/'''/,"string","@herestring.'''"],[/"/,{cases:{"@eos":"string","@default":{token:"string",next:'@string."'}}}],[/'/,{cases:{"@eos":"string","@default":{token:"string",next:"@string.'"}}}]],string:[[/[^"'\#\\]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/\./,"string.escape.invalid"],[/#{/,{cases:{'$S2=="':{token:"string",next:"root.interpolatedstring"},"@default":"string"}}],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/#/,"string"]],herestring:[[/("""|''')/,{cases:{"$1==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/[^#\\'"]+/,"string"],[/['"]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/#{/,{token:"string.quote",next:"root.interpolatedstring"}],[/#/,"string"]],comment:[[/[^#]+/,"comment"],[/###/,"comment","@pop"],[/#/,"comment"]],hereregexp:[[/[^\\\/#]+/,"regexp"],[/\\./,"regexp"],[/#.*$/,"comment"],["///[igm]*",{token:"regexp",next:"@pop"}],[/\//,"regexp"]]}};return c(m);})();
-return moduleExports;
-});

web/public/vs/basic-languages/csharp/csharp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/csharp/csharp", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},p=(t,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!c.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(i=r(e,n))||i.enumerable});return t};var g=t=>p(s({},"__esModule",{value:!0}),t);var u={};l(u,{conf:()=>d,language:()=>m});var d={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'}],folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},m={defaultToken:"",tokenPostfix:".cs",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["extern","alias","using","bool","decimal","sbyte","byte","short","ushort","int","uint","long","ulong","char","float","double","object","dynamic","string","assembly","is","as","ref","out","this","base","new","typeof","void","checked","unchecked","default","delegate","var","const","if","else","switch","case","while","do","for","foreach","in","break","continue","goto","return","throw","try","catch","finally","lock","yield","from","let","where","join","on","equals","into","orderby","ascending","descending","select","group","by","namespace","partial","class","field","event","method","param","public","protected","internal","private","abstract","sealed","static","struct","readonly","volatile","virtual","override","params","get","set","add","remove","operator","true","false","implicit","explicit","interface","enum","null","async","await","fixed","sizeof","stackalloc","unsafe","nameof","when"],namespaceFollows:["namespace","using"],parenFollows:["if","for","while","switch","foreach","using","catch","when"],operators:["=","??","||","&&","|","^","&","==","!=","<=",">=","<<","+","-","*","/","%","!","~","++","--","+=","-=","*=","/=","%=","&=","|=","^=","<<=",">>=",">>","=>"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/\@?[a-zA-Z_]\w*/,{cases:{"@namespaceFollows":{token:"keyword.$0",next:"@namespace"},"@keywords":{token:"keyword.$0",next:"@qualified"},"@default":{token:"identifier",next:"@qualified"}}}],{include:"@whitespace"},[/}/,{cases:{"$S2==interpolatedstring":{token:"string.quote",next:"@pop"},"$S2==litinterpstring":{token:"string.quote",next:"@pop"},"@default":"@brackets"}}],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/,"number.float"],[/0[xX][0-9a-fA-F_]+/,"number.hex"],[/0[bB][01_]+/,"number.hex"],[/[0-9_]+/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,{token:"string.quote",next:"@string"}],[/\$\@"/,{token:"string.quote",next:"@litinterpstring"}],[/\@"/,{token:"string.quote",next:"@litstring"}],[/\$"/,{token:"string.quote",next:"@interpolatedstring"}],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],qualified:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],[/\./,"delimiter"],["","","@pop"]],namespace:[{include:"@whitespace"},[/[A-Z]\w*/,"namespace"],[/[\.=]/,"delimiter"],["","","@pop"]],comment:[[/[^\/*]+/,"comment"],["\\*/","comment","@pop"],[/[\/*]/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,{token:"string.quote",next:"@pop"}]],litstring:[[/[^"]+/,"string"],[/""/,"string.escape"],[/"/,{token:"string.quote",next:"@pop"}]],litinterpstring:[[/[^"{]+/,"string"],[/""/,"string.escape"],[/{{/,"string.escape"],[/}}/,"string.escape"],[/{/,{token:"string.quote",next:"root.litinterpstring"}],[/"/,{token:"string.quote",next:"@pop"}]],interpolatedstring:[[/[^\\"{]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/{{/,"string.escape"],[/}}/,"string.escape"],[/{/,{token:"string.quote",next:"root.interpolatedstring"}],[/"/,{token:"string.quote",next:"@pop"}]],whitespace:[[/^[ \t\v\f]*#((r)|(load))(?=\s)/,"directive.csx"],[/^[ \t\v\f]*#\w.*$/,"namespace.cpp"],[/[ \t\v\f\r\n]+/,""],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return g(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/csp/csp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/csp/csp", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var o=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var a=(r,t)=>{for(var s in t)o(r,s,{get:t[s],enumerable:!0})},c=(r,t,s,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of u(t))!g.call(r,e)&&e!==s&&o(r,e,{get:()=>t[e],enumerable:!(n=i(t,e))||n.enumerable});return r};var q=r=>c(o({},"__esModule",{value:!0}),r);var p={};a(p,{conf:()=>f,language:()=>l});var f={brackets:[],autoClosingPairs:[],surroundingPairs:[]},l={keywords:[],typeKeywords:[],tokenPostfix:".csp",operators:[],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/child-src/,"string.quote"],[/connect-src/,"string.quote"],[/default-src/,"string.quote"],[/font-src/,"string.quote"],[/frame-src/,"string.quote"],[/img-src/,"string.quote"],[/manifest-src/,"string.quote"],[/media-src/,"string.quote"],[/object-src/,"string.quote"],[/script-src/,"string.quote"],[/style-src/,"string.quote"],[/worker-src/,"string.quote"],[/base-uri/,"string.quote"],[/plugin-types/,"string.quote"],[/sandbox/,"string.quote"],[/disown-opener/,"string.quote"],[/form-action/,"string.quote"],[/frame-ancestors/,"string.quote"],[/report-uri/,"string.quote"],[/report-to/,"string.quote"],[/upgrade-insecure-requests/,"string.quote"],[/block-all-mixed-content/,"string.quote"],[/require-sri-for/,"string.quote"],[/reflected-xss/,"string.quote"],[/referrer/,"string.quote"],[/policy-uri/,"string.quote"],[/'self'/,"string.quote"],[/'unsafe-inline'/,"string.quote"],[/'unsafe-eval'/,"string.quote"],[/'strict-dynamic'/,"string.quote"],[/'unsafe-hashed-attributes'/,"string.quote"]]}};return q(p);})();
-return moduleExports;
-});

web/public/vs/basic-languages/css/css.js

@@ -1,12 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/css/css", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var m=(t,e)=>{for(var o in e)r(t,o,{get:e[o],enumerable:!0})},c=(t,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of s(e))!l.call(t,n)&&n!==o&&r(t,n,{get:()=>e[n],enumerable:!(i=a(e,n))||i.enumerable});return t};var d=t=>c(r({},"__esModule",{value:!0}),t);var k={};m(k,{conf:()=>u,language:()=>p});var u={wordPattern:/(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,comments:{blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),end:new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")}}},p={defaultToken:"",tokenPostfix:".css",ws:`[ 	
-\r\f]*`,identifier:"-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",brackets:[{open:"{",close:"}",token:"delimiter.bracket"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],tokenizer:{root:[{include:"@selector"}],selector:[{include:"@comments"},{include:"@import"},{include:"@strings"},["[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",{token:"keyword",next:"@keyframedeclaration"}],["[@](page|content|font-face|-moz-document)",{token:"keyword"}],["[@](charset|namespace)",{token:"keyword",next:"@declarationbody"}],["(url-prefix)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],["(url)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],{include:"@selectorname"},["[\\*]","tag"],["[>\\+,]","delimiter"],["\\[",{token:"delimiter.bracket",next:"@selectorattribute"}],["{",{token:"delimiter.bracket",next:"@selectorbody"}]],selectorbody:[{include:"@comments"},["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))","attribute.name","@rulevalue"],["}",{token:"delimiter.bracket",next:"@pop"}]],selectorname:[["(\\.|#(?=[^{])|%|(@identifier)|:)+","tag"]],selectorattribute:[{include:"@term"},["]",{token:"delimiter.bracket",next:"@pop"}]],term:[{include:"@comments"},["(url-prefix)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],["(url)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],{include:"@functioninvocation"},{include:"@numbers"},{include:"@name"},{include:"@strings"},["([<>=\\+\\-\\*\\/\\^\\|\\~,])","delimiter"],[",","delimiter"]],rulevalue:[{include:"@comments"},{include:"@strings"},{include:"@term"},["!important","keyword"],[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],warndebug:[["[@](warn|debug)",{token:"keyword",next:"@declarationbody"}]],import:[["[@](import)",{token:"keyword",next:"@declarationbody"}]],urldeclaration:[{include:"@strings"},[`[^)\r
-]+`,"string"],["\\)",{token:"delimiter.parenthesis",next:"@pop"}]],parenthizedterm:[{include:"@term"},["\\)",{token:"delimiter.parenthesis",next:"@pop"}]],declarationbody:[{include:"@term"},[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],comments:[["\\/\\*","comment","@comment"],["\\/\\/+.*","comment"]],comment:[["\\*\\/","comment","@pop"],[/[^*/]+/,"comment"],[/./,"comment"]],name:[["@identifier","attribute.value"]],numbers:[["-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?",{token:"attribute.value.number",next:"@units"}],["#[0-9a-fA-F_]+(?!\\w)","attribute.value.hex"]],units:[["(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?","attribute.value.unit","@pop"]],keyframedeclaration:[["@identifier","attribute.value"],["{",{token:"delimiter.bracket",switchTo:"@keyframebody"}]],keyframebody:[{include:"@term"},["{",{token:"delimiter.bracket",next:"@selectorbody"}],["}",{token:"delimiter.bracket",next:"@pop"}]],functioninvocation:[["@identifier\\(",{token:"attribute.value",next:"@functionarguments"}]],functionarguments:[["\\$@identifier@ws:","attribute.name"],["[,]","delimiter"],{include:"@term"},["\\)",{token:"attribute.value",next:"@pop"}]],strings:[['~?"',{token:"string",next:"@stringenddoublequote"}],["~?'",{token:"string",next:"@stringendquote"}]],stringenddoublequote:[["\\\\.","string"],['"',{token:"string",next:"@pop"}],[/[^\\"]+/,"string"],[".","string"]],stringendquote:[["\\\\.","string"],["'",{token:"string",next:"@pop"}],[/[^\\']+/,"string"],[".","string"]]}};return d(k);})();
-return moduleExports;
-});

web/public/vs/basic-languages/cypher/cypher.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/cypher/cypher", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(i,e)=>{for(var n in e)s(i,n,{get:e[n],enumerable:!0})},g=(i,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!l.call(i,t)&&t!==n&&s(i,t,{get:()=>e[t],enumerable:!(o=r(e,t))||o.enumerable});return i};var p=i=>g(s({},"__esModule",{value:!0}),i);var u={};c(u,{conf:()=>d,language:()=>m});var d={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"`",close:"`"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"`",close:"`"}]},m={defaultToken:"",tokenPostfix:".cypher",ignoreCase:!0,brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"}],keywords:["ALL","AND","AS","ASC","ASCENDING","BY","CALL","CASE","CONTAINS","CREATE","DELETE","DESC","DESCENDING","DETACH","DISTINCT","ELSE","END","ENDS","EXISTS","IN","IS","LIMIT","MANDATORY","MATCH","MERGE","NOT","ON","ON","OPTIONAL","OR","ORDER","REMOVE","RETURN","SET","SKIP","STARTS","THEN","UNION","UNWIND","WHEN","WHERE","WITH","XOR","YIELD"],builtinLiterals:["true","TRUE","false","FALSE","null","NULL"],builtinFunctions:["abs","acos","asin","atan","atan2","avg","ceil","coalesce","collect","cos","cot","count","degrees","e","endNode","exists","exp","floor","head","id","keys","labels","last","left","length","log","log10","lTrim","max","min","nodes","percentileCont","percentileDisc","pi","properties","radians","rand","range","relationships","replace","reverse","right","round","rTrim","sign","sin","size","split","sqrt","startNode","stDev","stDevP","substring","sum","tail","tan","timestamp","toBoolean","toFloat","toInteger","toLower","toString","toUpper","trim","type"],operators:["+","-","*","/","%","^","=","<>","<",">","<=",">=","->","<-","-->","<--"],escapes:/\\(?:[tbnrf\\"'`]|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+/,octaldigits:/[0-7]+/,hexdigits:/[0-9a-fA-F]+/,tokenizer:{root:[[/[{}[\]()]/,"@brackets"],{include:"common"}],common:[{include:"@whitespace"},{include:"@numbers"},{include:"@strings"},[/:[a-zA-Z_][\w]*/,"type.identifier"],[/[a-zA-Z_][\w]*(?=\()/,{cases:{"@builtinFunctions":"predefined.function"}}],[/[a-zA-Z_$][\w$]*/,{cases:{"@keywords":"keyword","@builtinLiterals":"predefined.literal","@default":"identifier"}}],[/`/,"identifier.escape","@identifierBacktick"],[/[;,.:|]/,"delimiter"],[/[<>=%+\-*/^]+/,{cases:{"@operators":"delimiter","@default":""}}]],numbers:[[/-?(@digits)[eE](-?(@digits))?/,"number.float"],[/-?(@digits)?\.(@digits)([eE]-?(@digits))?/,"number.float"],[/-?0x(@hexdigits)/,"number.hex"],[/-?0(@octaldigits)/,"number.octal"],[/-?(@digits)/,"number"]],strings:[[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string","@stringDouble"],[/'/,"string","@stringSingle"]],whitespace:[[/[ \t\r\n]+/,"white"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/\/\/.*/,"comment"],[/[^/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[/*]/,"comment"]],stringDouble:[[/[^\\"]+/,"string"],[/@escapes/,"string"],[/\\./,"string.invalid"],[/"/,"string","@pop"]],stringSingle:[[/[^\\']+/,"string"],[/@escapes/,"string"],[/\\./,"string.invalid"],[/'/,"string","@pop"]],identifierBacktick:[[/[^\\`]+/,"identifier.escape"],[/@escapes/,"identifier.escape"],[/\\./,"identifier.escape.invalid"],[/`/,"identifier.escape","@pop"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/dart/dart.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/dart/dart", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var p=(n,e)=>{for(var t in e)r(n,t,{get:e[t],enumerable:!0})},g=(n,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of c(e))!a.call(n,o)&&o!==t&&r(n,o,{get:()=>e[o],enumerable:!(s=i(e,o))||s.enumerable});return n};var l=n=>g(r({},"__esModule",{value:!0}),n);var x={};p(x,{conf:()=>d,language:()=>m});var d={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string"]},{open:"`",close:"`",notIn:["string","comment"]},{open:"/**",close:" */",notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:"(",close:")"},{open:'"',close:'"'},{open:"`",close:"`"}],folding:{markers:{start:/^\s*\s*#?region\b/,end:/^\s*\s*#?endregion\b/}}},m={defaultToken:"invalid",tokenPostfix:".dart",keywords:["abstract","dynamic","implements","show","as","else","import","static","assert","enum","in","super","async","export","interface","switch","await","extends","is","sync","break","external","library","this","case","factory","mixin","throw","catch","false","new","true","class","final","null","try","const","finally","on","typedef","continue","for","operator","var","covariant","Function","part","void","default","get","rethrow","while","deferred","hide","return","with","do","if","set","yield"],typeKeywords:["int","double","String","bool"],operators:["+","-","*","/","~/","%","++","--","==","!=",">","<",">=","<=","=","-=","/=","%=",">>=","^=","+=","*=","~/=","<<=","&=","!=","||","&&","&","|","^","~","<<",">>","!",">>>","??","?",":","|="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,regexpctl:/[(){}\[\]\$\^|\-*+?\.]/,regexpesc:/\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,tokenizer:{root:[[/[{}]/,"delimiter.bracket"],{include:"common"}],common:[[/[a-z_$][\w$]*/,{cases:{"@typeKeywords":"type.identifier","@keywords":"keyword","@default":"identifier"}}],[/[A-Z_$][\w\$]*/,"type.identifier"],{include:"@whitespace"},[/\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,{token:"regexp",bracket:"@open",next:"@regexp"}],[/@[a-zA-Z]+/,"annotation"],[/[()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/!(?=([^=]|$))/,"delimiter"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/(@digits)[eE]([\-+]?(@digits))?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?/,"number.float"],[/0[xX](@hexdigits)n?/,"number.hex"],[/0[oO]?(@octaldigits)n?/,"number.octal"],[/0[bB](@binarydigits)n?/,"number.binary"],[/(@digits)n?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string_double"],[/'/,"string","@string_single"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@jsdoc"],[/\/\*/,"comment","@comment"],[/\/\/\/.*$/,"comment.doc"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],jsdoc:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],regexp:[[/(\{)(\d+(?:,\d*)?)(\})/,["regexp.escape.control","regexp.escape.control","regexp.escape.control"]],[/(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,["regexp.escape.control",{token:"regexp.escape.control",next:"@regexrange"}]],[/(\()(\?:|\?=|\?!)/,["regexp.escape.control","regexp.escape.control"]],[/[()]/,"regexp.escape.control"],[/@regexpctl/,"regexp.escape.control"],[/[^\\\/]/,"regexp"],[/@regexpesc/,"regexp.escape"],[/\\\./,"regexp.invalid"],[/(\/)([gimsuy]*)/,[{token:"regexp",bracket:"@close",next:"@pop"},"keyword.other"]]],regexrange:[[/-/,"regexp.escape.control"],[/\^/,"regexp.invalid"],[/@regexpesc/,"regexp.escape"],[/[^\]]/,"regexp"],[/\]/,{token:"regexp.escape.control",next:"@pop",bracket:"@close"}]],string_double:[[/[^\\"\$]+/,"string"],[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"],[/\$\w+/,"identifier"]],string_single:[[/[^\\'\$]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/'/,"string","@pop"],[/\$\w+/,"identifier"]]}};return l(x);})();
-return moduleExports;
-});

web/public/vs/basic-languages/dockerfile/dockerfile.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/dockerfile/dockerfile", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var a=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var p=(o,e)=>{for(var s in e)a(o,s,{get:e[s],enumerable:!0})},g=(o,e,s,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of r(e))!i.call(o,n)&&n!==s&&a(o,n,{get:()=>e[n],enumerable:!(t=l(e,n))||t.enumerable});return o};var c=o=>g(a({},"__esModule",{value:!0}),o);var k={};p(k,{conf:()=>u,language:()=>d});var u={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},d={defaultToken:"",tokenPostfix:".dockerfile",variable:/\${?[\w]+}?/,tokenizer:{root:[{include:"@whitespace"},{include:"@comment"},[/(ONBUILD)(\s+)/,["keyword",""]],[/(ENV)(\s+)([\w]+)/,["keyword","",{token:"variable",next:"@arguments"}]],[/(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/,{token:"keyword",next:"@arguments"}]],arguments:[{include:"@whitespace"},{include:"@strings"},[/(@variable)/,{cases:{"@eos":{token:"variable",next:"@popall"},"@default":"variable"}}],[/\\/,{cases:{"@eos":"","@default":""}}],[/./,{cases:{"@eos":{token:"",next:"@popall"},"@default":""}}]],whitespace:[[/\s+/,{cases:{"@eos":{token:"",next:"@popall"},"@default":""}}]],comment:[[/(^#.*$)/,"comment","@popall"]],strings:[[/\\'$/,"","@popall"],[/\\'/,""],[/'$/,"string","@popall"],[/'/,"string","@stringBody"],[/"$/,"string","@popall"],[/"/,"string","@dblStringBody"]],stringBody:[[/[^\\\$']/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/\\./,"string.escape"],[/'$/,"string","@popall"],[/'/,"string","@pop"],[/(@variable)/,"variable"],[/\\$/,"string"],[/$/,"string","@popall"]],dblStringBody:[[/[^\\\$"]/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/\\./,"string.escape"],[/"$/,"string","@popall"],[/"/,"string","@pop"],[/(@variable)/,"variable"],[/\\$/,"string"],[/$/,"string","@popall"]]}};return c(k);})();
-return moduleExports;
-});

web/public/vs/basic-languages/flow9/flow9.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/flow9/flow9", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},m=(o,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(i=r(e,n))||i.enumerable});return o};var p=o=>m(s({},"__esModule",{value:!0}),o);var u={};c(u,{conf:()=>g,language:()=>f});var g={comments:{blockComment:["/*","*/"],lineComment:"//"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string"]},{open:"[",close:"]",notIn:["string"]},{open:"(",close:")",notIn:["string"]},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}]},f={defaultToken:"",tokenPostfix:".flow",keywords:["import","require","export","forbid","native","if","else","cast","unsafe","switch","default"],types:["io","mutable","bool","int","double","string","flow","void","ref","true","false","with"],operators:["=",">","<","<=",">=","==","!","!=",":=","::=","&&","||","+","-","*","/","@","&","%",":","->","\\","$","??","^"],symbols:/[@$=><!~?:&|+\-*\\\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":"keyword","@types":"type","@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"delimiter"],[/[<>](?!@symbols)/,"delimiter"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/fsharp/fsharp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/fsharp/fsharp", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(n,e)=>{for(var o in e)s(n,o,{get:e[o],enumerable:!0})},g=(n,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!l.call(n,t)&&t!==o&&s(n,t,{get:()=>e[t],enumerable:!(i=r(e,t))||i.enumerable});return n};var f=n=>g(s({},"__esModule",{value:!0}),n);var d={};c(d,{conf:()=>m,language:()=>u});var m={comments:{lineComment:"//",blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),end:new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")}}},u={defaultToken:"",tokenPostfix:".fs",keywords:["abstract","and","atomic","as","assert","asr","base","begin","break","checked","component","const","constraint","constructor","continue","class","default","delegate","do","done","downcast","downto","elif","else","end","exception","eager","event","external","extern","false","finally","for","fun","function","fixed","functor","global","if","in","include","inherit","inline","interface","internal","land","lor","lsl","lsr","lxor","lazy","let","match","member","mod","module","mutable","namespace","method","mixin","new","not","null","of","open","or","object","override","private","parallel","process","protected","pure","public","rec","return","static","sealed","struct","sig","then","to","true","tailcall","trait","try","type","upcast","use","val","void","virtual","volatile","when","while","with","yield"],symbols:/[=><!~?:&|+\-*\^%;\.,\/]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,integersuffix:/[uU]?[yslnLI]?/,floatsuffix:/[fFmM]?/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/\[<.*>\]/,"annotation"],[/^#(if|else|endif)/,"keyword"],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/,"number.float"],[/0x[0-9a-fA-F]+LF/,"number.float"],[/0x[0-9a-fA-F]+(@integersuffix)/,"number.hex"],[/0b[0-1]+(@integersuffix)/,"number.bin"],[/\d+(@integersuffix)/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"""/,"string",'@string."""'],[/"/,"string",'@string."'],[/\@"/,{token:"string.quote",next:"@litstring"}],[/'[^\\']'B?/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\(\*(?!\))/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^*(]+/,"comment"],[/\*\)/,"comment","@pop"],[/\*/,"comment"],[/\(\*\)/,"comment"],[/\(/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/("""|"B?)/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]],litstring:[[/[^"]+/,"string"],[/""/,"string.escape"],[/"/,{token:"string.quote",next:"@pop"}]]}};return f(d);})();
-return moduleExports;
-});

web/public/vs/basic-languages/go/go.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/go/go", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var m=(n,e)=>{for(var t in e)s(n,t,{get:e[t],enumerable:!0})},l=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of a(e))!c.call(n,o)&&o!==t&&s(n,o,{get:()=>e[o],enumerable:!(r=i(e,o))||r.enumerable});return n};var g=n=>l(s({},"__esModule",{value:!0}),n);var d={};m(d,{conf:()=>p,language:()=>u});var p={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"`",close:"`",notIn:["string"]},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"`",close:"`"},{open:'"',close:'"'},{open:"'",close:"'"}]},u={defaultToken:"",tokenPostfix:".go",keywords:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var","bool","true","false","uint8","uint16","uint32","uint64","int8","int16","int32","int64","float32","float64","complex64","complex128","byte","rune","uint","int","uintptr","string","nil"],operators:["+","-","*","/","%","&","|","^","<<",">>","&^","+=","-=","*=","/=","%=","&=","|=","^=","<<=",">>=","&^=","&&","||","<-","++","--","==","<",">","=","!","!=","<=",">=",":=","...","(",")","","]","{","}",",",";",".",":"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/\[\[.*\]\]/,"annotation"],[/^\s*#\w+/,"keyword"],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F']*[0-9a-fA-F]/,"number.hex"],[/0[0-7']*[0-7]/,"number.octal"],[/0[bB][0-1']*[0-1]/,"number.binary"],[/\d[\d']*/,"number"],[/\d/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"],[/`/,"string","@rawstring"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@doccomment"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],doccomment:[[/[^\/*]+/,"comment.doc"],[/\/\*/,"comment.doc.invalid"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],rawstring:[[/[^\`]/,"string"],[/`/,"string","@pop"]]}};return g(d);})();
-return moduleExports;
-});

web/public/vs/basic-languages/graphql/graphql.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/graphql/graphql", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(n,e)=>{for(var t in e)s(n,t,{get:e[t],enumerable:!0})},d=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of i(e))!l.call(n,o)&&o!==t&&s(n,o,{get:()=>e[o],enumerable:!(r=a(e,o))||r.enumerable});return n};var p=n=>d(s({},"__esModule",{value:!0}),n);var u={};c(u,{conf:()=>g,language:()=>I});var g={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"""',close:'"""',notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"""',close:'"""'},{open:'"',close:'"'}],folding:{offSide:!0}},I={defaultToken:"invalid",tokenPostfix:".gql",keywords:["null","true","false","query","mutation","subscription","extend","schema","directive","scalar","type","interface","union","enum","input","implements","fragment","on"],typeKeywords:["Int","Float","String","Boolean","ID"],directiveLocations:["SCHEMA","SCALAR","OBJECT","FIELD_DEFINITION","ARGUMENT_DEFINITION","INTERFACE","UNION","ENUM","ENUM_VALUE","INPUT_OBJECT","INPUT_FIELD_DEFINITION","QUERY","MUTATION","SUBSCRIPTION","FIELD","FRAGMENT_DEFINITION","FRAGMENT_SPREAD","INLINE_FRAGMENT","VARIABLE_DEFINITION"],operators:["=","!","?",":","&","|"],symbols:/[=!?:&|]+/,escapes:/\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})/,tokenizer:{root:[[/[a-z_][\w$]*/,{cases:{"@keywords":"keyword","@default":"key.identifier"}}],[/[$][\w$]*/,{cases:{"@keywords":"keyword","@default":"argument.identifier"}}],[/[A-Z][\w\$]*/,{cases:{"@typeKeywords":"keyword","@default":"type.identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/@symbols/,{cases:{"@operators":"operator","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,{token:"annotation",log:"annotation token: $0"}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F]+/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/"""/,{token:"string",next:"@mlstring",nextEmbedded:"markdown"}],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,{token:"string.quote",bracket:"@open",next:"@string"}]],mlstring:[[/[^"]+/,"string"],['"""',{token:"string",next:"@pop",nextEmbedded:"@pop"}]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,""],[/#.*$/,"comment"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/hcl/hcl.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/hcl/hcl", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var o in e)r(t,o,{get:e[o],enumerable:!0})},d=(t,e,o,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of i(e))!c.call(t,s)&&s!==o&&r(t,s,{get:()=>e[s],enumerable:!(n=a(e,s))||n.enumerable});return t};var m=t=>d(r({},"__esModule",{value:!0}),t);var f={};l(f,{conf:()=>p,language:()=>g});var p={comments:{lineComment:"#",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},g={defaultToken:"",tokenPostfix:".hcl",keywords:["var","local","path","for_each","any","string","number","bool","true","false","null","if ","else ","endif ","for ","in","endfor"],operators:["=",">=","<=","==","!=","+","-","*","/","%","&&","||","!","<",">","?","...",":"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,terraformFunctions:/(abs|ceil|floor|log|max|min|pow|signum|chomp|format|formatlist|indent|join|lower|regex|regexall|replace|split|strrev|substr|title|trimspace|upper|chunklist|coalesce|coalescelist|compact|concat|contains|distinct|element|flatten|index|keys|length|list|lookup|map|matchkeys|merge|range|reverse|setintersection|setproduct|setunion|slice|sort|transpose|values|zipmap|base64decode|base64encode|base64gzip|csvdecode|jsondecode|jsonencode|urlencode|yamldecode|yamlencode|abspath|dirname|pathexpand|basename|file|fileexists|fileset|filebase64|templatefile|formatdate|timeadd|timestamp|base64sha256|base64sha512|bcrypt|filebase64sha256|filebase64sha512|filemd5|filemd1|filesha256|filesha512|md5|rsadecrypt|sha1|sha256|sha512|uuid|uuidv5|cidrhost|cidrnetmask|cidrsubnet|tobool|tolist|tomap|tonumber|toset|tostring)/,terraformMainBlocks:/(module|data|terraform|resource|provider|variable|output|locals)/,tokenizer:{root:[[/^@terraformMainBlocks([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,["type","","string","","string","","@brackets"]],[/(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,["identifier","","string","","string","","@brackets"]],[/(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)(=)(\{)/,["identifier","","string","","operator","","@brackets"]],{include:"@terraform"}],terraform:[[/@terraformFunctions(\()/,["type","@brackets"]],[/[a-zA-Z_]\w*-*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"variable"}}],{include:"@whitespace"},{include:"@heredoc"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"operator","@default":""}}],[/\d*\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\d[\d']*/,"number"],[/\d/,"number"],[/[;,.]/,"delimiter"],[/"/,"string","@string"],[/'/,"invalid"]],heredoc:[[/<<[-]*\s*["]?([\w\-]+)["]?/,{token:"string.heredoc.delimiter",next:"@heredocBody.$1"}]],heredocBody:[[/([\w\-]+)$/,{cases:{"$1==$S2":[{token:"string.heredoc.delimiter",next:"@popall"}],"@default":"string.heredoc"}}],[/./,"string.heredoc"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"],[/#.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],string:[[/\$\{/,{token:"delimiter",next:"@stringExpression"}],[/[^\\"\$]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@popall"]],stringInsideExpression:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],stringExpression:[[/\}/,{token:"delimiter",next:"@pop"}],[/"/,"string","@stringInsideExpression"],{include:"@terraform"}]}};return m(f);})();
-return moduleExports;
-});

web/public/vs/basic-languages/ini/ini.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/ini/ini", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var t=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var c=(n,e)=>{for(var s in e)t(n,s,{get:e[s],enumerable:!0})},l=(n,e,s,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of r(e))!g.call(n,o)&&o!==s&&t(n,o,{get:()=>e[o],enumerable:!(a=i(e,o))||a.enumerable});return n};var p=n=>l(t({},"__esModule",{value:!0}),n);var f={};c(f,{conf:()=>u,language:()=>m});var u={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},m={defaultToken:"",tokenPostfix:".ini",escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/^\[[^\]]*\]/,"metatag"],[/(^\w+)(\s*)(\=)/,["key","","delimiter"]],{include:"@whitespace"},[/\d+/,"number"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string",'@string."'],[/'/,"string","@string.'"]],whitespace:[[/[ \t\r\n]+/,""],[/^\s*[#;].*$/,"comment"]],string:[[/[^\\"']+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]]}};return p(f);})();
-return moduleExports;
-});

web/public/vs/basic-languages/java/java.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/java/java", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},d=(t,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of r(e))!c.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(i=a(e,n))||i.enumerable});return t};var g=t=>d(s({},"__esModule",{value:!0}),t);var f={};l(f,{conf:()=>m,language:()=>p});var m={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}],folding:{markers:{start:new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),end:new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")}}},p={defaultToken:"",tokenPostfix:".java",keywords:["abstract","continue","for","new","switch","assert","default","goto","package","synchronized","boolean","do","if","private","this","break","double","implements","protected","throw","byte","else","import","public","throws","case","enum","instanceof","return","transient","catch","extends","int","short","try","char","final","interface","static","void","class","finally","long","strictfp","volatile","const","float","native","super","while","true","false","yield","record","sealed","non-sealed","permits"],operators:["=",">","<","!","~","?",":","==","<=",">=","!=","&&","||","++","--","+","-","*","/","&","|","^","%","<<",">>",">>>","+=","-=","*=","/=","&=","|=","^=","%=","<<=",">>=",">>>="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,tokenizer:{root:[["non-sealed","keyword.non-sealed"],[/[a-zA-Z_$][\w$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,"annotation"],[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,"number.float"],[/0[xX](@hexdigits)[Ll]?/,"number.hex"],[/0(@octaldigits)[Ll]?/,"number.octal"],[/0[bB](@binarydigits)[Ll]?/,"number.binary"],[/(@digits)[fFdD]/,"number.float"],[/(@digits)[lL]?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"""/,"string","@multistring"],[/"/,"string","@string"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@javadoc"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],javadoc:[[/[^\/*]+/,"comment.doc"],[/\/\*/,"comment.doc.invalid"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],multistring:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"""/,"string","@pop"],[/./,"string"]]}};return g(f);})();
-return moduleExports;
-});

web/public/vs/basic-languages/kotlin/kotlin.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/kotlin/kotlin", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(n,e)=>{for(var i in e)o(n,i,{get:e[i],enumerable:!0})},d=(n,e,i,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of r(e))!c.call(n,t)&&t!==i&&o(n,t,{get:()=>e[t],enumerable:!(s=a(e,t))||s.enumerable});return n};var g=n=>d(o({},"__esModule",{value:!0}),n);var f={};l(f,{conf:()=>m,language:()=>p});var m={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}],folding:{markers:{start:new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),end:new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")}}},p={defaultToken:"",tokenPostfix:".kt",keywords:["as","as?","break","class","continue","do","else","false","for","fun","if","in","!in","interface","is","!is","null","object","package","return","super","this","throw","true","try","typealias","val","var","when","while","by","catch","constructor","delegate","dynamic","field","file","finally","get","import","init","param","property","receiver","set","setparam","where","actual","abstract","annotation","companion","const","crossinline","data","enum","expect","external","final","infix","inline","inner","internal","lateinit","noinline","open","operator","out","override","private","protected","public","reified","sealed","suspend","tailrec","vararg","field","it"],operators:["+","-","*","/","%","=","+=","-=","*=","/=","%=","++","--","&&","||","!","==","!=","===","!==",">","<","<=",">=","[","]","!!","?.","?:","::","..",":","?","->","@",";","$","_"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,tokenizer:{root:[[/[A-Z][\w\$]*/,"type.identifier"],[/[a-zA-Z_$][\w$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,"annotation"],[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,"number.float"],[/0[xX](@hexdigits)[Ll]?/,"number.hex"],[/0(@octaldigits)[Ll]?/,"number.octal"],[/0[bB](@binarydigits)[Ll]?/,"number.binary"],[/(@digits)[fFdD]/,"number.float"],[/(@digits)[lL]?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"""/,"string","@multistring"],[/"/,"string","@string"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@javadoc"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\/\*/,"comment","@comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],javadoc:[[/[^\/*]+/,"comment.doc"],[/\/\*/,"comment.doc","@push"],[/\/\*/,"comment.doc.invalid"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],multistring:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"""/,"string","@pop"],[/./,"string"]]}};return g(f);})();
-return moduleExports;
-});

web/public/vs/basic-languages/less/less.js

@@ -1,11 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/less/less", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var d=(t,e)=>{for(var i in e)r(t,i,{get:e[i],enumerable:!0})},u=(t,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(t,n)&&n!==i&&r(t,n,{get:()=>e[n],enumerable:!(o=s(e,n))||o.enumerable});return t};var c=t=>u(r({},"__esModule",{value:!0}),t);var p={};d(p,{conf:()=>m,language:()=>g});var m={wordPattern:/(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,comments:{blockComment:["/*","*/"],lineComment:"//"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),end:new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")}}},g={defaultToken:"",tokenPostfix:".less",identifier:"-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",identifierPlus:"-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],tokenizer:{root:[{include:"@nestedJSBegin"},["[ \\t\\r\\n]+",""],{include:"@comments"},{include:"@keyword"},{include:"@strings"},{include:"@numbers"},["[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))","attribute.name","@attribute"],["url(\\-prefix)?\\(",{token:"tag",next:"@urldeclaration"}],["[{}()\\[\\]]","@brackets"],["[,:;]","delimiter"],["#@identifierPlus","tag.id"],["&","tag"],["\\.@identifierPlus(?=\\()","tag.class","@attribute"],["\\.@identifierPlus","tag.class"],["@identifierPlus","tag"],{include:"@operators"},["@(@identifier(?=[:,\\)]))","variable","@attribute"],["@(@identifier)","variable"],["@","key","@atRules"]],nestedJSBegin:[["``","delimiter.backtick"],["`",{token:"delimiter.backtick",next:"@nestedJSEnd",nextEmbedded:"text/javascript"}]],nestedJSEnd:[["`",{token:"delimiter.backtick",next:"@pop",nextEmbedded:"@pop"}]],operators:[["[<>=\\+\\-\\*\\/\\^\\|\\~]","operator"]],keyword:[["(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b","keyword"]],urldeclaration:[{include:"@strings"},[`[^)\r
-]+`,"string"],["\\)",{token:"tag",next:"@pop"}]],attribute:[{include:"@nestedJSBegin"},{include:"@comments"},{include:"@strings"},{include:"@numbers"},{include:"@keyword"},["[a-zA-Z\\-]+(?=\\()","attribute.value","@attribute"],[">","operator","@pop"],["@identifier","attribute.value"],{include:"@operators"},["@(@identifier)","variable"],["[)\\}]","@brackets","@pop"],["[{}()\\[\\]>]","@brackets"],["[;]","delimiter","@pop"],["[,=:]","delimiter"],["\\s",""],[".","attribute.value"]],comments:[["\\/\\*","comment","@comment"],["\\/\\/+.*","comment"]],comment:[["\\*\\/","comment","@pop"],[".","comment"]],numbers:[["(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?",{token:"attribute.value.number",next:"@units"}],["#[0-9a-fA-F_]+(?!\\w)","attribute.value.hex"]],units:[["(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?","attribute.value.unit","@pop"]],strings:[['~?"',{token:"string.delimiter",next:"@stringsEndDoubleQuote"}],["~?'",{token:"string.delimiter",next:"@stringsEndQuote"}]],stringsEndDoubleQuote:[['\\\\"',"string"],['"',{token:"string.delimiter",next:"@popall"}],[".","string"]],stringsEndQuote:[["\\\\'","string"],["'",{token:"string.delimiter",next:"@popall"}],[".","string"]],atRules:[{include:"@comments"},{include:"@strings"},["[()]","delimiter"],["[\\{;]","delimiter","@pop"],[".","key"]]}};return c(p);})();
-return moduleExports;
-});

web/public/vs/basic-languages/lexon/lexon.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/lexon/lexon", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var n=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var i in e)n(t,i,{get:e[i],enumerable:!0})},p=(t,e,i,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of d(e))!a.call(t,o)&&o!==i&&n(t,o,{get:()=>e[o],enumerable:!(r=s(e,o))||r.enumerable});return t};var c=t=>p(n({},"__esModule",{value:!0}),t);var k={};l(k,{conf:()=>m,language:()=>u});var m={comments:{lineComment:"COMMENT"},brackets:[["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:":",close:"."}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"`",close:"`"},{open:'"',close:'"'},{open:"'",close:"'"},{open:":",close:"."}],folding:{markers:{start:new RegExp("^\\s*(::\\s*|COMMENT\\s+)#region"),end:new RegExp("^\\s*(::\\s*|COMMENT\\s+)#endregion")}}},u={tokenPostfix:".lexon",ignoreCase:!0,keywords:["lexon","lex","clause","terms","contracts","may","pay","pays","appoints","into","to"],typeKeywords:["amount","person","key","time","date","asset","text"],operators:["less","greater","equal","le","gt","or","and","add","added","subtract","subtracted","multiply","multiplied","times","divide","divided","is","be","certified"],symbols:/[=><!~?:&|+\-*\/\^%]+/,tokenizer:{root:[[/^(\s*)(comment:?(?:\s.*|))$/,["","comment"]],[/"/,{token:"identifier.quote",bracket:"@open",next:"@quoted_identifier"}],["LEX$",{token:"keyword",bracket:"@open",next:"@identifier_until_period"}],["LEXON",{token:"keyword",bracket:"@open",next:"@semver"}],[":",{token:"delimiter",bracket:"@open",next:"@identifier_until_period"}],[/[a-z_$][\w$]*/,{cases:{"@operators":"operator","@typeKeywords":"keyword.type","@keywords":"keyword","@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\.\d*\.\d*/,"number.semver"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F]+/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"]],quoted_identifier:[[/[^\\"]+/,"identifier"],[/"/,{token:"identifier.quote",bracket:"@close",next:"@pop"}]],space_identifier_until_period:[[":","delimiter"],[" ",{token:"white",next:"@identifier_rest"}]],identifier_until_period:[{include:"@whitespace"},[":",{token:"delimiter",next:"@identifier_rest"}],[/[^\\.]+/,"identifier"],[/\./,{token:"delimiter",bracket:"@close",next:"@pop"}]],identifier_rest:[[/[^\\.]+/,"identifier"],[/\./,{token:"delimiter",bracket:"@close",next:"@pop"}]],semver:[{include:"@whitespace"},[":","delimiter"],[/\d*\.\d*\.\d*/,{token:"number.semver",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"]]}};return c(k);})();
-return moduleExports;
-});

web/public/vs/basic-languages/liquid/liquid.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/liquid/liquid", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var p=Object.create;var a=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var h=Object.getPrototypeOf,q=Object.prototype.hasOwnProperty;var f=(e=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(e,{get:(t,i)=>(typeof require<"u"?require:t)[i]}):e)(function(e){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+e+'" is not supported')});var b=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),T=(e,t)=>{for(var i in t)a(e,i,{get:t[i],enumerable:!0})},r=(e,t,i,l)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of w(t))!q.call(e,o)&&o!==i&&a(e,o,{get:()=>t[o],enumerable:!(l=g(t,o))||l.enumerable});return e},d=(e,t,i)=>(r(e,t,"default"),i&&r(i,t,"default")),s=(e,t,i)=>(i=e!=null?p(h(e)):{},r(t||!e||!e.__esModule?a(i,"default",{value:e,enumerable:!0}):i,e)),k=e=>r(a({},"__esModule",{value:!0}),e);var c=b((y,u)=>{var _=s(f("vs/editor/editor.api"));u.exports=_});var $={};T($,{conf:()=>x,language:()=>S});var n={};d(n,s(c()));var m=["area","base","br","col","embed","hr","img","input","keygen","link","menuitem","meta","param","source","track","wbr"],x={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,brackets:[["<!--","-->"],["<",">"],["{{","}}"],["{%","%}"],["{","}"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"%",close:"%"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"<",close:">"},{open:'"',close:'"'},{open:"'",close:"'"}],onEnterRules:[{beforeText:new RegExp(`<(?!(?:${m.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`,"i"),afterText:/^<\/(\w[\w\d]*)\s*>$/i,action:{indentAction:n.languages.IndentAction.IndentOutdent}},{beforeText:new RegExp(`<(?!(?:${m.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`,"i"),action:{indentAction:n.languages.IndentAction.Indent}}]},S={defaultToken:"",tokenPostfix:"",builtinTags:["if","else","elseif","endif","render","assign","capture","endcapture","case","endcase","comment","endcomment","cycle","decrement","for","endfor","include","increment","layout","raw","endraw","render","tablerow","endtablerow","unless","endunless"],builtinFilters:["abs","append","at_least","at_most","capitalize","ceil","compact","date","default","divided_by","downcase","escape","escape_once","first","floor","join","json","last","lstrip","map","minus","modulo","newline_to_br","plus","prepend","remove","remove_first","replace","replace_first","reverse","round","rstrip","size","slice","sort","sort_natural","split","strip","strip_html","strip_newlines","times","truncate","truncatewords","uniq","upcase","url_decode","url_encode","where"],constants:["true","false"],operators:["==","!=",">","<",">=","<="],symbol:/[=><!]+/,identifier:/[a-zA-Z_][\w]*/,tokenizer:{root:[[/\{\%\s*comment\s*\%\}/,"comment.start.liquid","@comment"],[/\{\{/,{token:"@rematch",switchTo:"@liquidState.root"}],[/\{\%/,{token:"@rematch",switchTo:"@liquidState.root"}],[/(<)([\w\-]+)(\/>)/,["delimiter.html","tag.html","delimiter.html"]],[/(<)([:\w]+)/,["delimiter.html",{token:"tag.html",next:"@otherTag"}]],[/(<\/)([\w\-]+)/,["delimiter.html",{token:"tag.html",next:"@otherTag"}]],[/</,"delimiter.html"],[/\{/,"delimiter.html"],[/[^<{]+/]],comment:[[/\{\%\s*endcomment\s*\%\}/,"comment.end.liquid","@pop"],[/./,"comment.content.liquid"]],otherTag:[[/\{\{/,{token:"@rematch",switchTo:"@liquidState.otherTag"}],[/\{\%/,{token:"@rematch",switchTo:"@liquidState.otherTag"}],[/\/?>/,"delimiter.html","@pop"],[/"([^"]*)"/,"attribute.value"],[/'([^']*)'/,"attribute.value"],[/[\w\-]+/,"attribute.name"],[/=/,"delimiter"],[/[ \t\r\n]+/]],liquidState:[[/\{\{/,"delimiter.output.liquid"],[/\}\}/,{token:"delimiter.output.liquid",switchTo:"@$S2.$S3"}],[/\{\%/,"delimiter.tag.liquid"],[/raw\s*\%\}/,"delimiter.tag.liquid","@liquidRaw"],[/\%\}/,{token:"delimiter.tag.liquid",switchTo:"@$S2.$S3"}],{include:"liquidRoot"}],liquidRaw:[[/^(?!\{\%\s*endraw\s*\%\}).+/],[/\{\%/,"delimiter.tag.liquid"],[/@identifier/],[/\%\}/,{token:"delimiter.tag.liquid",next:"@root"}]],liquidRoot:[[/\d+(\.\d+)?/,"number.liquid"],[/"[^"]*"/,"string.liquid"],[/'[^']*'/,"string.liquid"],[/\s+/],[/@symbol/,{cases:{"@operators":"operator.liquid","@default":""}}],[/\./],[/@identifier/,{cases:{"@constants":"keyword.liquid","@builtinFilters":"predefined.liquid","@builtinTags":"predefined.liquid","@default":"variable.liquid"}}],[/[^}|%]/,"variable.liquid"]]}};return k($);})();
-return moduleExports;
-});

web/public/vs/basic-languages/lua/lua.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/lua/lua", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},m=(o,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of i(e))!l.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(r=a(e,n))||r.enumerable});return o};var p=o=>m(s({},"__esModule",{value:!0}),o);var u={};c(u,{conf:()=>d,language:()=>g});var d={comments:{lineComment:"--",blockComment:["--[[","]]"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},g={defaultToken:"",tokenPostfix:".lua",keywords:["and","break","do","else","elseif","end","false","for","function","goto","if","in","local","nil","not","or","repeat","return","then","true","until","while"],brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.array",open:"[",close:"]"},{token:"delimiter.parenthesis",open:"(",close:")"}],operators:["+","-","*","/","%","^","#","==","~=","<=",">=","<",">","=",";",":",",",".","..","..."],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/,["delimiter","","key","","delimiter"]],[/({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/,["@brackets","","key","","delimiter"]],[/[{}()\[\]]/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string",'@string."'],[/'/,"string","@string.'"]],whitespace:[[/[ \t\r\n]+/,""],[/--\[([=]*)\[/,"comment","@comment.$1"],[/--.*$/,"comment"]],comment:[[/[^\]]+/,"comment"],[/\]([=]*)\]/,{cases:{"$1==$S2":{token:"comment",next:"@pop"},"@default":"comment"}}],[/./,"comment"]],string:[[/[^\\"']+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/m3/m3.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/m3/m3", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var R=(o,e)=>{for(var s in e)r(o,s,{get:e[s],enumerable:!0})},c=(o,e,s,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!i.call(o,t)&&t!==s&&r(o,t,{get:()=>e[t],enumerable:!(n=E(e,t))||n.enumerable});return o};var m=o=>c(r({},"__esModule",{value:!0}),o);var N={};R(N,{conf:()=>A,language:()=>p});var A={comments:{blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"[",close:"]"},{open:"{",close:"}"},{open:"(",close:")"},{open:"(*",close:"*)"},{open:"<*",close:"*>"},{open:"'",close:"'",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]}]},p={defaultToken:"",tokenPostfix:".m3",brackets:[{token:"delimiter.curly",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"}],keywords:["AND","ANY","ARRAY","AS","BEGIN","BITS","BRANDED","BY","CASE","CONST","DIV","DO","ELSE","ELSIF","END","EVAL","EXCEPT","EXCEPTION","EXIT","EXPORTS","FINALLY","FOR","FROM","GENERIC","IF","IMPORT","IN","INTERFACE","LOCK","LOOP","METHODS","MOD","MODULE","NOT","OBJECT","OF","OR","OVERRIDES","PROCEDURE","RAISE","RAISES","READONLY","RECORD","REF","REPEAT","RETURN","REVEAL","SET","THEN","TO","TRY","TYPE","TYPECASE","UNSAFE","UNTIL","UNTRACED","VALUE","VAR","WHILE","WITH"],reservedConstNames:["ABS","ADR","ADRSIZE","BITSIZE","BYTESIZE","CEILING","DEC","DISPOSE","FALSE","FIRST","FLOAT","FLOOR","INC","ISTYPE","LAST","LOOPHOLE","MAX","MIN","NARROW","NEW","NIL","NUMBER","ORD","ROUND","SUBARRAY","TRUE","TRUNC","TYPECODE","VAL"],reservedTypeNames:["ADDRESS","ANY","BOOLEAN","CARDINAL","CHAR","EXTENDED","INTEGER","LONGCARD","LONGINT","LONGREAL","MUTEX","NULL","REAL","REFANY","ROOT","TEXT"],operators:["+","-","*","/","&","^","."],relations:["=","#","<","<=",">",">=","<:",":"],delimiters:["|","..","=>",",",";",":="],symbols:/[>=<#.,:;+\-*/&^]+/,escapes:/\\(?:[\\fnrt"']|[0-7]{3})/,tokenizer:{root:[[/_\w*/,"invalid"],[/[a-zA-Z][a-zA-Z0-9_]*/,{cases:{"@keywords":{token:"keyword.$0"},"@reservedConstNames":{token:"constant.reserved.$0"},"@reservedTypeNames":{token:"type.reserved.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[0-9]+\.[0-9]+(?:[DdEeXx][\+\-]?[0-9]+)?/,"number.float"],[/[0-9]+(?:\_[0-9a-fA-F]+)?L?/,"number"],[/@symbols/,{cases:{"@operators":"operators","@relations":"operators","@delimiters":"delimiter","@default":"invalid"}}],[/'[^\\']'/,"string.char"],[/(')(@escapes)(')/,["string.char","string.escape","string.char"]],[/'/,"invalid"],[/"([^"\\]|\\.)*$/,"invalid"],[/"/,"string.text","@text"]],text:[[/[^\\"]+/,"string.text"],[/@escapes/,"string.escape"],[/\\./,"invalid"],[/"/,"string.text","@pop"]],comment:[[/\(\*/,"comment","@push"],[/\*\)/,"comment","@pop"],[/./,"comment"]],pragma:[[/<\*/,"keyword.pragma","@push"],[/\*>/,"keyword.pragma","@pop"],[/./,"keyword.pragma"]],whitespace:[[/[ \t\r\n]+/,"white"],[/\(\*/,"comment","@comment"],[/<\*/,"keyword.pragma","@pragma"]]}};return m(N);})();
-return moduleExports;
-});

web/public/vs/basic-languages/markdown/markdown.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/markdown/markdown", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},m=(t,e,o,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of c(e))!i.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(a=r(e,n))||a.enumerable});return t};var d=t=>m(s({},"__esModule",{value:!0}),t);var b={};l(b,{conf:()=>p,language:()=>g});var p={comments:{blockComment:["<!--","-->"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">",notIn:["string"]}],surroundingPairs:[{open:"(",close:")"},{open:"[",close:"]"},{open:"`",close:"`"}],folding:{markers:{start:new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),end:new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")}}},g={defaultToken:"",tokenPostfix:".md",control:/[\\`*_\[\]{}()#+\-\.!]/,noncontrol:/[^\\`*_\[\]{}()#+\-\.!]/,escapes:/\\(?:@control)/,jsescapes:/\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,empty:["area","base","basefont","br","col","frame","hr","img","input","isindex","link","meta","param"],tokenizer:{root:[[/^\s*\|/,"@rematch","@table_header"],[/^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/,["white","keyword","keyword","keyword"]],[/^\s*(=+|\-+)\s*$/,"keyword"],[/^\s*((\*[ ]?)+)\s*$/,"meta.separator"],[/^\s*>+/,"comment"],[/^\s*([\*\-+:]|\d+\.)\s/,"keyword"],[/^(\t|[ ]{4})[^ ].*$/,"string"],[/^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/,{token:"string",next:"@codeblock"}],[/^\s*```\s*((?:\w|[\/\-#])+).*$/,{token:"string",next:"@codeblockgh",nextEmbedded:"$1"}],[/^\s*```\s*$/,{token:"string",next:"@codeblock"}],{include:"@linecontent"}],table_header:[{include:"@table_common"},[/[^\|]+/,"keyword.table.header"]],table_body:[{include:"@table_common"},{include:"@linecontent"}],table_common:[[/\s*[\-:]+\s*/,{token:"keyword",switchTo:"table_body"}],[/^\s*\|/,"keyword.table.left"],[/^\s*[^\|]/,"@rematch","@pop"],[/^\s*$/,"@rematch","@pop"],[/\|/,{cases:{"@eos":"keyword.table.right","@default":"keyword.table.middle"}}]],codeblock:[[/^\s*~~~\s*$/,{token:"string",next:"@pop"}],[/^\s*```\s*$/,{token:"string",next:"@pop"}],[/.*$/,"variable.source"]],codeblockgh:[[/```\s*$/,{token:"string",next:"@pop",nextEmbedded:"@pop"}],[/[^`]+/,"variable.source"]],linecontent:[[/&\w+;/,"string.escape"],[/@escapes/,"escape"],[/\b__([^\\_]|@escapes|_(?!_))+__\b/,"strong"],[/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/,"strong"],[/\b_[^_]+_\b/,"emphasis"],[/\*([^\\*]|@escapes)+\*/,"emphasis"],[/`([^\\`]|@escapes)+`/,"variable"],[/\{+[^}]+\}+/,"string.target"],[/(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/,["string.link","","string.link"]],[/(!?\[)((?:[^\]\\]|@escapes)*)(\])/,"string.link"],{include:"html"}],html:[[/<(\w+)\/>/,"tag"],[/<(\w+)(\-|\w)*/,{cases:{"@empty":{token:"tag",next:"@tag.$1"},"@default":{token:"tag",next:"@tag.$1"}}}],[/<\/(\w+)(\-|\w)*\s*>/,{token:"tag"}],[/<!--/,"comment","@comment"]],comment:[[/[^<\-]+/,"comment.content"],[/-->/,"comment","@pop"],[/<!--/,"comment.content.invalid"],[/[<\-]/,"comment.content"]],tag:[[/[ \t\r\n]+/,"white"],[/(type)(\s*=\s*)(")([^"]+)(")/,["attribute.name.html","delimiter.html","string.html",{token:"string.html",switchTo:"@tag.$S2.$4"},"string.html"]],[/(type)(\s*=\s*)(')([^']+)(')/,["attribute.name.html","delimiter.html","string.html",{token:"string.html",switchTo:"@tag.$S2.$4"},"string.html"]],[/(\w+)(\s*=\s*)("[^"]*"|'[^']*')/,["attribute.name.html","delimiter.html","string.html"]],[/\w+/,"attribute.name.html"],[/\/>/,"tag","@pop"],[/>/,{cases:{"$S2==style":{token:"tag",switchTo:"embeddedStyle",nextEmbedded:"text/css"},"$S2==script":{cases:{$S3:{token:"tag",switchTo:"embeddedScript",nextEmbedded:"$S3"},"@default":{token:"tag",switchTo:"embeddedScript",nextEmbedded:"text/javascript"}}},"@default":{token:"tag",next:"@pop"}}}]],embeddedStyle:[[/[^<]+/,""],[/<\/style\s*>/,{token:"@rematch",next:"@pop",nextEmbedded:"@pop"}],[/</,""]],embeddedScript:[[/[^<]+/,""],[/<\/script\s*>/,{token:"@rematch",next:"@pop",nextEmbedded:"@pop"}],[/</,""]]}};return d(b);})();
-return moduleExports;
-});

web/public/vs/basic-languages/mips/mips.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/mips/mips", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var n in e)s(t,n,{get:e[n],enumerable:!0})},d=(t,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of o(e))!g.call(t,r)&&r!==n&&s(t,r,{get:()=>e[r],enumerable:!(i=a(e,r))||i.enumerable});return t};var m=t=>d(s({},"__esModule",{value:!0}),t);var x={};l(x,{conf:()=>p,language:()=>u});var p={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{blockComment:["###","###"],lineComment:"#"},folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},u={defaultToken:"",ignoreCase:!1,tokenPostfix:".mips",regEx:/\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,keywords:[".data",".text","syscall","trap","add","addu","addi","addiu","and","andi","div","divu","mult","multu","nor","or","ori","sll","slv","sra","srav","srl","srlv","sub","subu","xor","xori","lhi","lho","lhi","llo","slt","slti","sltu","sltiu","beq","bgtz","blez","bne","j","jal","jalr","jr","lb","lbu","lh","lhu","lw","li","la","sb","sh","sw","mfhi","mflo","mthi","mtlo","move"],symbols:/[\.,\:]+/,escapes:/\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/\$[a-zA-Z_]\w*/,"variable.predefined"],[/[.a-zA-Z_]\w*/,{cases:{this:"variable.predefined","@keywords":{token:"keyword.$0"},"@default":""}}],[/[ \t\r\n]+/,""],[/#.*$/,"comment"],["///",{token:"regexp",next:"@hereregexp"}],[/^(\s*)(@regEx)/,["","regexp"]],[/(\,)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\:)(\s*)(@regEx)/,["delimiter","","regexp"]],[/@symbols/,"delimiter"],[/\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d+\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F]+/,"number.hex"],[/0[0-7]+(?!\d)/,"number.octal"],[/\d+/,"number"],[/[,.]/,"delimiter"],[/"""/,"string",'@herestring."""'],[/'''/,"string","@herestring.'''"],[/"/,{cases:{"@eos":"string","@default":{token:"string",next:'@string."'}}}],[/'/,{cases:{"@eos":"string","@default":{token:"string",next:"@string.'"}}}]],string:[[/[^"'\#\\]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/\./,"string.escape.invalid"],[/#{/,{cases:{'$S2=="':{token:"string",next:"root.interpolatedstring"},"@default":"string"}}],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/#/,"string"]],herestring:[[/("""|''')/,{cases:{"$1==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/[^#\\'"]+/,"string"],[/['"]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/#{/,{token:"string.quote",next:"root.interpolatedstring"}],[/#/,"string"]],comment:[[/[^#]+/,"comment"],[/#/,"comment"]],hereregexp:[[/[^\\\/#]+/,"regexp"],[/\\./,"regexp"],[/#.*$/,"comment"],["///[igm]*",{token:"regexp",next:"@pop"}],[/\//,"regexp"]]}};return m(x);})();
-return moduleExports;
-});

web/public/vs/basic-languages/objective-c/objective-c.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/objective-c/objective-c", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var l=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},p=(o,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of c(e))!a.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(i=r(e,n))||i.enumerable});return o};var d=o=>p(s({},"__esModule",{value:!0}),o);var u={};l(u,{conf:()=>g,language:()=>m});var g={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},m={defaultToken:"",tokenPostfix:".objective-c",keywords:["#import","#include","#define","#else","#endif","#if","#ifdef","#ifndef","#ident","#undef","@class","@defs","@dynamic","@encode","@end","@implementation","@interface","@package","@private","@protected","@property","@protocol","@public","@selector","@synthesize","__declspec","assign","auto","BOOL","break","bycopy","byref","case","char","Class","const","copy","continue","default","do","double","else","enum","extern","FALSE","false","float","for","goto","if","in","int","id","inout","IMP","long","nil","nonatomic","NULL","oneway","out","private","public","protected","readwrite","readonly","register","return","SEL","self","short","signed","sizeof","static","struct","super","switch","typedef","TRUE","true","union","unsigned","volatile","void","while"],decpart:/\d(_?\d)*/,decimal:/0|@decpart/,tokenizer:{root:[{include:"@comments"},{include:"@whitespace"},{include:"@numbers"},{include:"@strings"},[/[,:;]/,"delimiter"],[/[{}\[\]()<>]/,"@brackets"],[/[a-zA-Z@#]\w*/,{cases:{"@keywords":"keyword","@default":"identifier"}}],[/[<>=\\+\\-\\*\\/\\^\\|\\~,]|and\\b|or\\b|not\\b]/,"operator"]],whitespace:[[/\s+/,"white"]],comments:[["\\/\\*","comment","@comment"],["\\/\\/+.*","comment"]],comment:[["\\*\\/","comment","@pop"],[".","comment"]],numbers:[[/0[xX][0-9a-fA-F]*(_?[0-9a-fA-F])*/,"number.hex"],[/@decimal((\.@decpart)?([eE][\-+]?@decpart)?)[fF]*/,{cases:{"(\\d)*":"number",$0:"number.float"}}]],strings:[[/'$/,"string.escape","@popall"],[/'/,"string.escape","@stringBody"],[/"$/,"string.escape","@popall"],[/"/,"string.escape","@dblStringBody"]],stringBody:[[/[^\\']+$/,"string","@popall"],[/[^\\']+/,"string"],[/\\./,"string"],[/'/,"string.escape","@popall"],[/\\$/,"string"]],dblStringBody:[[/[^\\"]+$/,"string","@popall"],[/[^\\"]+/,"string"],[/\\./,"string"],[/"/,"string.escape","@popall"],[/\\$/,"string"]]}};return d(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/pascal/pascal.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/pascal/pascal", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var n=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var r in e)n(t,r,{get:e[r],enumerable:!0})},d=(t,e,r,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of a(e))!l.call(t,o)&&o!==r&&n(t,o,{get:()=>e[o],enumerable:!(i=s(e,o))||i.enumerable});return t};var p=t=>d(n({},"__esModule",{value:!0}),t);var g={};c(g,{conf:()=>m,language:()=>u});var m={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["{","}"]},brackets:[["{","}"],["[","]"],["(",")"],["<",">"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),end:new RegExp("^\\s*\\{\\$ENDREGION\\}")}}},u={defaultToken:"",tokenPostfix:".pascal",ignoreCase:!0,brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["absolute","abstract","all","and_then","array","as","asm","attribute","begin","bindable","case","class","const","contains","default","div","else","end","except","exports","external","far","file","finalization","finally","forward","generic","goto","if","implements","import","in","index","inherited","initialization","interrupt","is","label","library","mod","module","name","near","not","object","of","on","only","operator","or_else","otherwise","override","package","packed","pow","private","program","protected","public","published","interface","implementation","qualified","read","record","resident","requires","resourcestring","restricted","segment","set","shl","shr","specialize","stored","strict","then","threadvar","to","try","type","unit","uses","var","view","virtual","dynamic","overload","reintroduce","with","write","xor","true","false","procedure","function","constructor","destructor","property","break","continue","exit","abort","while","do","for","raise","repeat","until"],typeKeywords:["boolean","double","byte","integer","shortint","char","longint","float","string"],operators:["=",">","<","<=",">=","<>",":",":=","and","or","+","-","*","/","@","&","^","%"],symbols:/[=><:@\^&|+\-*\/\^%]+/,tokenizer:{root:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\$[0-9a-fA-F]{1,16}/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/'/,"string","@string"],[/'[^\\']'/,"string"],[/'/,"string.invalid"],[/\#\d+/,"string"]],comment:[[/[^\*\}]+/,"comment"],[/\}/,"comment","@pop"],[/[\{]/,"comment"]],string:[[/[^\\']+/,"string"],[/\\./,"string.escape.invalid"],[/'/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"],[/\{/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return p(g);})();
-return moduleExports;
-});

web/public/vs/basic-languages/pascaligo/pascaligo.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/pascaligo/pascaligo", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},m=(o,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(r=i(e,n))||r.enumerable});return o};var p=o=>m(s({},"__esModule",{value:!0}),o);var u={};c(u,{conf:()=>d,language:()=>g});var d={comments:{lineComment:"//",blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"],["<",">"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"}]},g={defaultToken:"",tokenPostfix:".pascaligo",ignoreCase:!0,brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["begin","block","case","const","else","end","fail","for","from","function","if","is","nil","of","remove","return","skip","then","type","var","while","with","option","None","transaction"],typeKeywords:["bool","int","list","map","nat","record","string","unit","address","map","mtz","xtz"],operators:["=",">","<","<=",">=","<>",":",":=","and","mod","or","+","-","*","/","@","&","^","%"],symbols:/[=><:@\^&|+\-*\/\^%]+/,tokenizer:{root:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\$[0-9a-fA-F]{1,16}/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/'/,"string","@string"],[/'[^\\']'/,"string"],[/'/,"string.invalid"],[/\#\d+/,"string"]],comment:[[/[^\(\*]+/,"comment"],[/\*\)/,"comment","@pop"],[/\(\*/,"comment"]],string:[[/[^\\']+/,"string"],[/\\./,"string.escape.invalid"],[/'/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"],[/\(\*/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/pla/pla.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/pla/pla", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var l=(o,e)=>{for(var n in e)s(o,n,{get:e[n],enumerable:!0})},c=(o,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of r(e))!p.call(o,t)&&t!==n&&s(o,t,{get:()=>e[t],enumerable:!(i=a(e,t))||i.enumerable});return o};var d=o=>c(s({},"__esModule",{value:!0}),o);var u={};l(u,{conf:()=>k,language:()=>m});var k={comments:{lineComment:"#"},brackets:[["[","]"],["<",">"],["(",")"]],autoClosingPairs:[{open:"[",close:"]"},{open:"<",close:">"},{open:"(",close:")"}],surroundingPairs:[{open:"[",close:"]"},{open:"<",close:">"},{open:"(",close:")"}]},m={defaultToken:"",tokenPostfix:".pla",brackets:[{open:"[",close:"]",token:"delimiter.square"},{open:"<",close:">",token:"delimiter.angle"},{open:"(",close:")",token:"delimiter.parenthesis"}],keywords:[".i",".o",".mv",".ilb",".ob",".label",".type",".phase",".pair",".symbolic",".symbolic-output",".kiss",".p",".e",".end"],comment:/#.*$/,identifier:/[a-zA-Z]+[a-zA-Z0-9_\-]*/,plaContent:/[01\-~\|]+/,tokenizer:{root:[{include:"@whitespace"},[/@comment/,"comment"],[/\.([a-zA-Z_\-]+)/,{cases:{"@eos":{token:"keyword.$1"},"@keywords":{cases:{".type":{token:"keyword.$1",next:"@type"},"@default":{token:"keyword.$1",next:"@keywordArg"}}},"@default":{token:"keyword.$1"}}}],[/@identifier/,"identifier"],[/@plaContent/,"string"]],whitespace:[[/[ \t\r\n]+/,""]],type:[{include:"@whitespace"},[/\w+/,{token:"type",next:"@pop"}]],keywordArg:[[/[ \t\r\n]+/,{cases:{"@eos":{token:"",next:"@pop"},"@default":""}}],[/@comment/,"comment","@pop"],[/[<>()\[\]]/,{cases:{"@eos":{token:"@brackets",next:"@pop"},"@default":"@brackets"}}],[/\-?\d+/,{cases:{"@eos":{token:"number",next:"@pop"},"@default":"number"}}],[/@identifier/,{cases:{"@eos":{token:"identifier",next:"@pop"},"@default":"identifier"}}],[/[;=]/,{cases:{"@eos":{token:"delimiter",next:"@pop"},"@default":"delimiter"}}]]}};return d(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/powershell/powershell.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/powershell/powershell", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var o=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(n,e)=>{for(var t in e)o(n,t,{get:e[t],enumerable:!0})},g=(n,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of i(e))!l.call(n,s)&&s!==t&&o(n,s,{get:()=>e[s],enumerable:!(a=r(e,s))||a.enumerable});return n};var p=n=>g(o({},"__esModule",{value:!0}),n);var u={};c(u,{conf:()=>d,language:()=>m});var d={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"#",blockComment:["<#","#>"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},m={defaultToken:"",ignoreCase:!0,tokenPostfix:".ps1",brackets:[{token:"delimiter.curly",open:"{",close:"}"},{token:"delimiter.square",open:"[",close:"]"},{token:"delimiter.parenthesis",open:"(",close:")"}],keywords:["begin","break","catch","class","continue","data","define","do","dynamicparam","else","elseif","end","exit","filter","finally","for","foreach","from","function","if","in","param","process","return","switch","throw","trap","try","until","using","var","while","workflow","parallel","sequence","inlinescript","configuration"],helpKeywords:/SYNOPSIS|DESCRIPTION|PARAMETER|EXAMPLE|INPUTS|OUTPUTS|NOTES|LINK|COMPONENT|ROLE|FUNCTIONALITY|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP/,symbols:/[=><!~?&%|+\-*\/\^;\.,]+/,escapes:/`(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_][\w-]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":""}}],[/[ \t\r\n]+/,""],[/^:\w*/,"metatag"],[/\$(\{((global|local|private|script|using):)?[\w]+\}|((global|local|private|script|using):)?[\w]+)/,"variable"],[/<#/,"comment","@comment"],[/#.*$/,"comment"],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+?/,"number"],[/[;,.]/,"delimiter"],[/\@"/,"string",'@herestring."'],[/\@'/,"string","@herestring.'"],[/"/,{cases:{"@eos":"string","@default":{token:"string",next:'@string."'}}}],[/'/,{cases:{"@eos":"string","@default":{token:"string",next:"@string.'"}}}]],string:[[/[^"'\$`]+/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/@escapes/,{cases:{"@eos":{token:"string.escape",next:"@popall"},"@default":"string.escape"}}],[/`./,{cases:{"@eos":{token:"string.escape.invalid",next:"@popall"},"@default":"string.escape.invalid"}}],[/\$[\w]+$/,{cases:{'$S2=="':{token:"variable",next:"@popall"},"@default":{token:"string",next:"@popall"}}}],[/\$[\w]+/,{cases:{'$S2=="':"variable","@default":"string"}}],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}}}]],herestring:[[/^\s*(["'])@/,{cases:{"$1==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/[^\$`]+/,"string"],[/@escapes/,"string.escape"],[/`./,"string.escape.invalid"],[/\$[\w]+/,{cases:{'$S2=="':"variable","@default":"string"}}]],comment:[[/[^#\.]+/,"comment"],[/#>/,"comment","@pop"],[/(\.)(@helpKeywords)(?!\w)/,{token:"comment.keyword.$2"}],[/[\.#]/,"comment"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/python/python.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/python/python", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var d=Object.create;var o=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var _=Object.getPrototypeOf,u=Object.prototype.hasOwnProperty;var b=(e=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(e,{get:(n,t)=>(typeof require<"u"?require:n)[t]}):e)(function(e){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+e+'" is not supported')});var y=(e,n)=>()=>(n||e((n={exports:{}}).exports,n),n.exports),h=(e,n)=>{for(var t in n)o(e,t,{get:n[t],enumerable:!0})},i=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let s of f(n))!u.call(e,s)&&s!==t&&o(e,s,{get:()=>n[s],enumerable:!(a=m(n,s))||a.enumerable});return e},l=(e,n,t)=>(i(e,n,"default"),t&&i(t,n,"default")),p=(e,n,t)=>(t=e!=null?d(_(e)):{},i(n||!e||!e.__esModule?o(t,"default",{value:e,enumerable:!0}):t,e)),x=e=>i(o({},"__esModule",{value:!0}),e);var g=y((B,c)=>{var w=p(b("vs/editor/editor.api"));c.exports=w});var D={};h(D,{conf:()=>k,language:()=>S});var r={};l(r,p(g()));var k={comments:{lineComment:"#",blockComment:["'''","'''"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],onEnterRules:[{beforeText:new RegExp("^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async|match|case).*?:\\s*$"),action:{indentAction:r.languages.IndentAction.Indent}}],folding:{offSide:!0,markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},S={defaultToken:"",tokenPostfix:".python",keywords:["False","None","True","_","and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","exec","finally","for","from","global","if","import","in","is","lambda","match","nonlocal","not","or","pass","print","raise","return","try","type","while","with","yield","int","float","long","complex","hex","abs","all","any","apply","basestring","bin","bool","buffer","bytearray","callable","chr","classmethod","cmp","coerce","compile","complex","delattr","dict","dir","divmod","enumerate","eval","execfile","file","filter","format","frozenset","getattr","globals","hasattr","hash","help","id","input","intern","isinstance","issubclass","iter","len","locals","list","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","reversed","range","raw_input","reduce","reload","repr","reversed","round","self","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","unichr","unicode","vars","xrange","zip","__dict__","__methods__","__members__","__class__","__bases__","__name__","__mro__","__subclasses__","__init__","__import__"],brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"}],tokenizer:{root:[{include:"@whitespace"},{include:"@numbers"},{include:"@strings"},[/[,:;]/,"delimiter"],[/[{}\[\]()]/,"@brackets"],[/@[a-zA-Z_]\w*/,"tag"],[/[a-zA-Z_]\w*/,{cases:{"@keywords":"keyword","@default":"identifier"}}]],whitespace:[[/\s+/,"white"],[/(^#.*$)/,"comment"],[/'''/,"string","@endDocString"],[/"""/,"string","@endDblDocString"]],endDocString:[[/[^']+/,"string"],[/\\'/,"string"],[/'''/,"string","@popall"],[/'/,"string"]],endDblDocString:[[/[^"]+/,"string"],[/\\"/,"string"],[/"""/,"string","@popall"],[/"/,"string"]],numbers:[[/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/,"number.hex"],[/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/,"number"]],strings:[[/'$/,"string.escape","@popall"],[/f'{1,3}/,"string.escape","@fStringBody"],[/'/,"string.escape","@stringBody"],[/"$/,"string.escape","@popall"],[/f"{1,3}/,"string.escape","@fDblStringBody"],[/"/,"string.escape","@dblStringBody"]],fStringBody:[[/[^\\'\{\}]+$/,"string","@popall"],[/[^\\'\{\}]+/,"string"],[/\{[^\}':!=]+/,"identifier","@fStringDetail"],[/\\./,"string"],[/'/,"string.escape","@popall"],[/\\$/,"string"]],stringBody:[[/[^\\']+$/,"string","@popall"],[/[^\\']+/,"string"],[/\\./,"string"],[/'/,"string.escape","@popall"],[/\\$/,"string"]],fDblStringBody:[[/[^\\"\{\}]+$/,"string","@popall"],[/[^\\"\{\}]+/,"string"],[/\{[^\}':!=]+/,"identifier","@fStringDetail"],[/\\./,"string"],[/"/,"string.escape","@popall"],[/\\$/,"string"]],dblStringBody:[[/[^\\"]+$/,"string","@popall"],[/[^\\"]+/,"string"],[/\\./,"string"],[/"/,"string.escape","@popall"],[/\\$/,"string"]],fStringDetail:[[/[:][^}]+/,"string"],[/[!][ars]/,"string"],[/=/,"string"],[/\}/,"identifier","@pop"]]}};return x(D);})();
-return moduleExports;
-});

web/public/vs/basic-languages/qsharp/qsharp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/qsharp/qsharp", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var a=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var n in e)a(t,n,{get:e[n],enumerable:!0})},p=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of r(e))!l.call(t,o)&&o!==n&&a(t,o,{get:()=>e[o],enumerable:!(s=i(e,o))||s.enumerable});return t};var u=t=>p(a({},"__esModule",{value:!0}),t);var w={};c(w,{conf:()=>d,language:()=>m});var d={comments:{lineComment:"//"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},m={keywords:["namespace","open","import","export","as","operation","function","body","adjoint","newtype","struct","controlled","if","elif","else","repeat","until","fixup","for","in","while","return","fail","within","apply","Adjoint","Controlled","Adj","Ctl","is","self","auto","distribute","invert","intrinsic","let","set","w/","new","not","and","or","use","borrow","using","borrowing","mutable","internal"],typeKeywords:["Unit","Int","BigInt","Double","Bool","String","Qubit","Result","Pauli","Range"],invalidKeywords:["abstract","base","bool","break","byte","case","catch","char","checked","class","const","continue","decimal","default","delegate","do","double","enum","event","explicit","extern","finally","fixed","float","foreach","goto","implicit","int","interface","lock","long","null","object","operator","out","override","params","private","protected","public","readonly","ref","sbyte","sealed","short","sizeof","stackalloc","static","string","switch","this","throw","try","typeof","unit","ulong","unchecked","unsafe","ushort","virtual","void","volatile"],constants:["true","false","PauliI","PauliX","PauliY","PauliZ","One","Zero"],builtin:["X","Y","Z","H","HY","S","T","SWAP","CNOT","CCNOT","MultiX","R","RFrac","Rx","Ry","Rz","R1","R1Frac","Exp","ExpFrac","Measure","M","MultiM","Message","Length","Assert","AssertProb","AssertEqual"],operators:["and=","<-","->","*","*=","@","!","^","^=",":","::",".","..","==","...","=","=>",">",">=","<","<=","-","-=","!=","or=","%","%=","|","+","+=","?","/","/=","&&&","&&&=","^^^","^^^=",">>>",">>>=","<<<","<<<=","|||","|||=","~~~","_","w/","w/="],namespaceFollows:["namespace","open"],importsFollows:["import"],symbols:/[=><!~?:&|+\-*\/\^%@._]+/,escapes:/\\[\s\S]/,tokenizer:{root:[[/[a-zA-Z_$][\w$]*/,{cases:{"@namespaceFollows":{token:"keyword.$0",next:"@namespace"},"@importsFollows":{token:"keyword.$0",next:"@imports"},"@typeKeywords":"type","@keywords":"keyword","@constants":"constant","@builtin":"keyword","@invalidKeywords":"invalid","@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/@symbols/,{cases:{"@operators":"operator","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/"/,{token:"string.quote",bracket:"@open",next:"@string"}]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/"/,{token:"string.quote",bracket:"@close",next:"@pop"}]],namespace:[{include:"@whitespace"},[/[A-Za-z]\w*/,"namespace"],[/[\.]/,"delimiter"],["","","@pop"]],imports:[{include:"@whitespace"},[/[A-Za-z]\w*(?=\.)/,"namespace"],[/[A-Za-z]\w*/,"identifier"],[/\*/,"wildcard"],[/[\.,]/,"delimiter"],["","","@pop"]],whitespace:[[/[ \t\r\n]+/,"white"],[/(\/\/).*/,"comment"]]}};return u(w);})();
-return moduleExports;
-});

web/public/vs/basic-languages/r/r.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/r/r", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var a=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(o,e)=>{for(var t in e)a(o,t,{get:e[t],enumerable:!0})},p=(o,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of i(e))!c.call(o,r)&&r!==t&&a(o,r,{get:()=>e[r],enumerable:!(n=s(e,r))||n.enumerable});return o};var m=o=>p(a({},"__esModule",{value:!0}),o);var u={};l(u,{conf:()=>d,language:()=>g});var d={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},g={defaultToken:"",tokenPostfix:".r",roxygen:["@alias","@aliases","@assignee","@author","@backref","@callGraph","@callGraphDepth","@callGraphPrimitives","@concept","@describeIn","@description","@details","@docType","@encoding","@evalNamespace","@evalRd","@example","@examples","@export","@exportClass","@exportMethod","@exportPattern","@family","@field","@formals","@format","@import","@importClassesFrom","@importFrom","@importMethodsFrom","@include","@inherit","@inheritDotParams","@inheritParams","@inheritSection","@keywords","@md","@method","@name","@noMd","@noRd","@note","@param","@rawNamespace","@rawRd","@rdname","@references","@return","@S3method","@section","@seealso","@setClass","@slot","@source","@template","@templateVar","@title","@TODO","@usage","@useDynLib"],constants:["NULL","FALSE","TRUE","NA","Inf","NaN","NA_integer_","NA_real_","NA_complex_","NA_character_","T","F","LETTERS","letters","month.abb","month.name","pi","R.version.string"],keywords:["break","next","return","if","else","for","in","repeat","while","array","category","character","complex","double","function","integer","list","logical","matrix","numeric","vector","data.frame","factor","library","require","attach","detach","source"],special:["\\n","\\r","\\t","\\b","\\a","\\f","\\v","\\'",'\\"',"\\\\"],brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"}],tokenizer:{root:[{include:"@numbers"},{include:"@strings"},[/[{}\[\]()]/,"@brackets"],{include:"@operators"},[/#'$/,"comment.doc"],[/#'/,"comment.doc","@roxygen"],[/(^#.*$)/,"comment"],[/\s+/,"white"],[/[,:;]/,"delimiter"],[/@[a-zA-Z]\w*/,"tag"],[/[a-zA-Z]\w*/,{cases:{"@keywords":"keyword","@constants":"constant","@default":"identifier"}}]],roxygen:[[/@\w+/,{cases:{"@roxygen":"tag","@eos":{token:"comment.doc",next:"@pop"},"@default":"comment.doc"}}],[/\s+/,{cases:{"@eos":{token:"comment.doc",next:"@pop"},"@default":"comment.doc"}}],[/.*/,{token:"comment.doc",next:"@pop"}]],numbers:[[/0[xX][0-9a-fA-F]+/,"number.hex"],[/-?(\d*\.)?\d+([eE][+\-]?\d+)?/,"number"]],operators:[[/<{1,2}-/,"operator"],[/->{1,2}/,"operator"],[/%[^%\s]+%/,"operator"],[/\*\*/,"operator"],[/%%/,"operator"],[/&&/,"operator"],[/\|\|/,"operator"],[/<</,"operator"],[/>>/,"operator"],[/[-+=&|!<>^~*/:$]/,"operator"]],strings:[[/'/,"string.escape","@stringBody"],[/"/,"string.escape","@dblStringBody"]],stringBody:[[/\\./,{cases:{"@special":"string","@default":"error-token"}}],[/'/,"string.escape","@popall"],[/./,"string"]],dblStringBody:[[/\\./,{cases:{"@special":"string","@default":"error-token"}}],[/"/,"string.escape","@popall"],[/./,"string"]]}};return m(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/redis/redis.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/redis/redis", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var R=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var N=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var A=(S,E)=>{for(var T in E)R(S,T,{get:E[T],enumerable:!0})},O=(S,E,T,o)=>{if(E&&typeof E=="object"||typeof E=="function")for(let e of N(E))!s.call(S,e)&&e!==T&&R(S,e,{get:()=>E[e],enumerable:!(o=n(E,e))||o.enumerable});return S};var L=S=>O(R({},"__esModule",{value:!0}),S);var r={};A(r,{conf:()=>I,language:()=>i});var I={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},i={defaultToken:"",tokenPostfix:".redis",ignoreCase:!0,brackets:[{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"}],keywords:["APPEND","AUTH","BGREWRITEAOF","BGSAVE","BITCOUNT","BITFIELD","BITOP","BITPOS","BLPOP","BRPOP","BRPOPLPUSH","CLIENT","KILL","LIST","GETNAME","PAUSE","REPLY","SETNAME","CLUSTER","ADDSLOTS","COUNT-FAILURE-REPORTS","COUNTKEYSINSLOT","DELSLOTS","FAILOVER","FORGET","GETKEYSINSLOT","INFO","KEYSLOT","MEET","NODES","REPLICATE","RESET","SAVECONFIG","SET-CONFIG-EPOCH","SETSLOT","SLAVES","SLOTS","COMMAND","COUNT","GETKEYS","CONFIG","GET","REWRITE","SET","RESETSTAT","DBSIZE","DEBUG","OBJECT","SEGFAULT","DECR","DECRBY","DEL","DISCARD","DUMP","ECHO","EVAL","EVALSHA","EXEC","EXISTS","EXPIRE","EXPIREAT","FLUSHALL","FLUSHDB","GEOADD","GEOHASH","GEOPOS","GEODIST","GEORADIUS","GEORADIUSBYMEMBER","GETBIT","GETRANGE","GETSET","HDEL","HEXISTS","HGET","HGETALL","HINCRBY","HINCRBYFLOAT","HKEYS","HLEN","HMGET","HMSET","HSET","HSETNX","HSTRLEN","HVALS","INCR","INCRBY","INCRBYFLOAT","KEYS","LASTSAVE","LINDEX","LINSERT","LLEN","LPOP","LPUSH","LPUSHX","LRANGE","LREM","LSET","LTRIM","MGET","MIGRATE","MONITOR","MOVE","MSET","MSETNX","MULTI","PERSIST","PEXPIRE","PEXPIREAT","PFADD","PFCOUNT","PFMERGE","PING","PSETEX","PSUBSCRIBE","PUBSUB","PTTL","PUBLISH","PUNSUBSCRIBE","QUIT","RANDOMKEY","READONLY","READWRITE","RENAME","RENAMENX","RESTORE","ROLE","RPOP","RPOPLPUSH","RPUSH","RPUSHX","SADD","SAVE","SCARD","SCRIPT","FLUSH","LOAD","SDIFF","SDIFFSTORE","SELECT","SETBIT","SETEX","SETNX","SETRANGE","SHUTDOWN","SINTER","SINTERSTORE","SISMEMBER","SLAVEOF","SLOWLOG","SMEMBERS","SMOVE","SORT","SPOP","SRANDMEMBER","SREM","STRLEN","SUBSCRIBE","SUNION","SUNIONSTORE","SWAPDB","SYNC","TIME","TOUCH","TTL","TYPE","UNSUBSCRIBE","UNLINK","UNWATCH","WAIT","WATCH","ZADD","ZCARD","ZCOUNT","ZINCRBY","ZINTERSTORE","ZLEXCOUNT","ZRANGE","ZRANGEBYLEX","ZREVRANGEBYLEX","ZRANGEBYSCORE","ZRANK","ZREM","ZREMRANGEBYLEX","ZREMRANGEBYRANK","ZREMRANGEBYSCORE","ZREVRANGE","ZREVRANGEBYSCORE","ZREVRANK","ZSCORE","ZUNIONSTORE","SCAN","SSCAN","HSCAN","ZSCAN"],operators:[],builtinFunctions:[],builtinVariables:[],pseudoColumns:[],tokenizer:{root:[{include:"@whitespace"},{include:"@pseudoColumns"},{include:"@numbers"},{include:"@strings"},{include:"@scopes"},[/[;,.]/,"delimiter"],[/[()]/,"@brackets"],[/[\w@#$]+/,{cases:{"@keywords":"keyword","@operators":"operator","@builtinVariables":"predefined","@builtinFunctions":"predefined","@default":"identifier"}}],[/[<>=!%&+\-*/|~^]/,"operator"]],whitespace:[[/\s+/,"white"]],pseudoColumns:[[/[$][A-Za-z_][\w@#$]*/,{cases:{"@pseudoColumns":"predefined","@default":"identifier"}}]],numbers:[[/0[xX][0-9a-fA-F]*/,"number"],[/[$][+-]*\d*(\.\d*)?/,"number"],[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/,"number"]],strings:[[/'/,{token:"string",next:"@string"}],[/"/,{token:"string.double",next:"@stringDouble"}]],string:[[/[^']+/,"string"],[/''/,"string"],[/'/,{token:"string",next:"@pop"}]],stringDouble:[[/[^"]+/,"string.double"],[/""/,"string.double"],[/"/,{token:"string.double",next:"@pop"}]],scopes:[]}};return L(r);})();
-return moduleExports;
-});

web/public/vs/basic-languages/restructuredtext/restructuredtext.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/restructuredtext/restructuredtext", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var t=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var r=Object.prototype.hasOwnProperty;var k=(n,e)=>{for(var i in e)t(n,i,{get:e[i],enumerable:!0})},c=(n,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of l(e))!r.call(n,s)&&s!==i&&t(n,s,{get:()=>e[s],enumerable:!(o=a(e,s))||o.enumerable});return n};var p=n=>c(t({},"__esModule",{value:!0}),n);var g={};k(g,{conf:()=>u,language:()=>m});var u={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">",notIn:["string"]}],surroundingPairs:[{open:"(",close:")"},{open:"[",close:"]"},{open:"`",close:"`"}],folding:{markers:{start:new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),end:new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")}}},m={defaultToken:"",tokenPostfix:".rst",control:/[\\`*_\[\]{}()#+\-\.!]/,escapes:/\\(?:@control)/,empty:["area","base","basefont","br","col","frame","hr","img","input","isindex","link","meta","param"],alphanumerics:/[A-Za-z0-9]/,simpleRefNameWithoutBq:/(?:@alphanumerics[-_+:.]*@alphanumerics)+|(?:@alphanumerics+)/,simpleRefName:/(?:`@phrase`|@simpleRefNameWithoutBq)/,phrase:/@simpleRefNameWithoutBq(?:\s@simpleRefNameWithoutBq)*/,citationName:/[A-Za-z][A-Za-z0-9-_.]*/,blockLiteralStart:/(?:[!"#$%&'()*+,-./:;<=>?@\[\]^_`{|}~]|[\s])/,precedingChars:/(?:[ -:/'"<([{])/,followingChars:/(?:[ -.,:;!?/'")\]}>]|$)/,punctuation:/(=|-|~|`|#|"|\^|\+|\*|:|\.|'|_|\+)/,tokenizer:{root:[[/^(@punctuation{3,}$){1,1}?/,"keyword"],[/^\s*([\*\-+‣•]|[a-zA-Z0-9]+\.|\([a-zA-Z0-9]+\)|[a-zA-Z0-9]+\))\s/,"keyword"],[/([ ]::)\s*$/,"keyword","@blankLineOfLiteralBlocks"],[/(::)\s*$/,"keyword","@blankLineOfLiteralBlocks"],{include:"@tables"},{include:"@explicitMarkupBlocks"},{include:"@inlineMarkup"}],explicitMarkupBlocks:[{include:"@citations"},{include:"@footnotes"},[/^(\.\.\s)(@simpleRefName)(::\s)(.*)$/,[{token:"",next:"subsequentLines"},"keyword","",""]],[/^(\.\.)(\s+)(_)(@simpleRefName)(:)(\s+)(.*)/,[{token:"",next:"hyperlinks"},"","","string.link","","","string.link"]],[/^((?:(?:\.\.)(?:\s+))?)(__)(:)(\s+)(.*)/,[{token:"",next:"subsequentLines"},"","","","string.link"]],[/^(__\s+)(.+)/,["","string.link"]],[/^(\.\.)( \|)([^| ]+[^|]*[^| ]*)(\| )(@simpleRefName)(:: .*)/,[{token:"",next:"subsequentLines"},"","string.link","","keyword",""],"@rawBlocks"],[/(\|)([^| ]+[^|]*[^| ]*)(\|_{0,2})/,["","string.link",""]],[/^(\.\.)([ ].*)$/,[{token:"",next:"@comments"},"comment"]]],inlineMarkup:[{include:"@citationsReference"},{include:"@footnotesReference"},[/(@simpleRefName)(_{1,2})/,["string.link",""]],[/(`)([^<`]+\s+)(<)(.*)(>)(`)(_)/,["","string.link","","string.link","","",""]],[/\*\*([^\\*]|\*(?!\*))+\*\*/,"strong"],[/\*[^*]+\*/,"emphasis"],[/(``)((?:[^`]|\`(?!`))+)(``)/,["","keyword",""]],[/(__\s+)(.+)/,["","keyword"]],[/(:)((?:@simpleRefNameWithoutBq)?)(:`)([^`]+)(`)/,["","keyword","","",""]],[/(`)([^`]+)(`:)((?:@simpleRefNameWithoutBq)?)(:)/,["","","","keyword",""]],[/(`)([^`]+)(`)/,""],[/(_`)(@phrase)(`)/,["","string.link",""]]],citations:[[/^(\.\.\s+\[)((?:@citationName))(\]\s+)(.*)/,[{token:"",next:"@subsequentLines"},"string.link","",""]]],citationsReference:[[/(\[)(@citationName)(\]_)/,["","string.link",""]]],footnotes:[[/^(\.\.\s+\[)((?:[0-9]+))(\]\s+.*)/,[{token:"",next:"@subsequentLines"},"string.link",""]],[/^(\.\.\s+\[)((?:#@simpleRefName?))(\]\s+)(.*)/,[{token:"",next:"@subsequentLines"},"string.link","",""]],[/^(\.\.\s+\[)((?:\*))(\]\s+)(.*)/,[{token:"",next:"@subsequentLines"},"string.link","",""]]],footnotesReference:[[/(\[)([0-9]+)(\])(_)/,["","string.link","",""]],[/(\[)(#@simpleRefName?)(\])(_)/,["","string.link","",""]],[/(\[)(\*)(\])(_)/,["","string.link","",""]]],blankLineOfLiteralBlocks:[[/^$/,"","@subsequentLinesOfLiteralBlocks"],[/^.*$/,"","@pop"]],subsequentLinesOfLiteralBlocks:[[/(@blockLiteralStart+)(.*)/,["keyword",""]],[/^(?!blockLiteralStart)/,"","@popall"]],subsequentLines:[[/^[\s]+.*/,""],[/^(?!\s)/,"","@pop"]],hyperlinks:[[/^[\s]+.*/,"string.link"],[/^(?!\s)/,"","@pop"]],comments:[[/^[\s]+.*/,"comment"],[/^(?!\s)/,"","@pop"]],tables:[[/\+-[+-]+/,"keyword"],[/\+=[+=]+/,"keyword"]]}};return p(g);})();
-return moduleExports;
-});

web/public/vs/basic-languages/rust/rust.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/rust/rust", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var _=(t,e)=>{for(var n in e)r(t,n,{get:e[n],enumerable:!0})},u=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of a(e))!c.call(t,o)&&o!==n&&r(t,o,{get:()=>e[o],enumerable:!(s=i(e,o))||s.enumerable});return t};var l=t=>u(r({},"__esModule",{value:!0}),t);var m={};_(m,{conf:()=>f,language:()=>p});var f={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"[",close:"]"},{open:"{",close:"}"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*#pragma\\s+region\\b"),end:new RegExp("^\\s*#pragma\\s+endregion\\b")}}},p={tokenPostfix:".rust",defaultToken:"invalid",keywords:["as","async","await","box","break","const","continue","crate","dyn","else","enum","extern","false","fn","for","if","impl","in","let","loop","match","mod","move","mut","pub","ref","return","self","static","struct","super","trait","true","try","type","unsafe","use","where","while","catch","default","union","static","abstract","alignof","become","do","final","macro","offsetof","override","priv","proc","pure","sizeof","typeof","unsized","virtual","yield"],typeKeywords:["Self","m32","m64","m128","f80","f16","f128","int","uint","float","char","bool","u8","u16","u32","u64","f32","f64","i8","i16","i32","i64","str","Option","Either","c_float","c_double","c_void","FILE","fpos_t","DIR","dirent","c_char","c_schar","c_uchar","c_short","c_ushort","c_int","c_uint","c_long","c_ulong","size_t","ptrdiff_t","clock_t","time_t","c_longlong","c_ulonglong","intptr_t","uintptr_t","off_t","dev_t","ino_t","pid_t","mode_t","ssize_t"],constants:["true","false","Some","None","Left","Right","Ok","Err"],supportConstants:["EXIT_FAILURE","EXIT_SUCCESS","RAND_MAX","EOF","SEEK_SET","SEEK_CUR","SEEK_END","_IOFBF","_IONBF","_IOLBF","BUFSIZ","FOPEN_MAX","FILENAME_MAX","L_tmpnam","TMP_MAX","O_RDONLY","O_WRONLY","O_RDWR","O_APPEND","O_CREAT","O_EXCL","O_TRUNC","S_IFIFO","S_IFCHR","S_IFBLK","S_IFDIR","S_IFREG","S_IFMT","S_IEXEC","S_IWRITE","S_IREAD","S_IRWXU","S_IXUSR","S_IWUSR","S_IRUSR","F_OK","R_OK","W_OK","X_OK","STDIN_FILENO","STDOUT_FILENO","STDERR_FILENO"],supportMacros:["format!","print!","println!","panic!","format_args!","unreachable!","write!","writeln!"],operators:["!","!=","%","%=","&","&=","&&","*","*=","+","+=","-","-=","->",".","..","...","/","/=",":",";","<<","<<=","<","<=","=","==","=>",">",">=",">>",">>=","@","^","^=","|","|=","||","_","?","#"],escapes:/\\([nrt0\"''\\]|x\h{2}|u\{\h{1,6}\})/,delimiters:/[,]/,symbols:/[\#\!\%\&\*\+\-\.\/\:\;\<\=\>\@\^\|_\?]+/,intSuffixes:/[iu](8|16|32|64|128|size)/,floatSuffixes:/f(32|64)/,tokenizer:{root:[[/r(#*)"/,{token:"string.quote",bracket:"@open",next:"@stringraw.$1"}],[/[a-zA-Z][a-zA-Z0-9_]*!?|_[a-zA-Z0-9_]+/,{cases:{"@typeKeywords":"keyword.type","@keywords":"keyword","@supportConstants":"keyword","@supportMacros":"keyword","@constants":"keyword","@default":"identifier"}}],[/\$/,"identifier"],[/'[a-zA-Z_][a-zA-Z0-9_]*(?=[^\'])/,"identifier"],[/'(\S|@escapes)'/,"string.byteliteral"],[/"/,{token:"string.quote",bracket:"@open",next:"@string"}],{include:"@numbers"},{include:"@whitespace"},[/@delimiters/,{cases:{"@keywords":"keyword","@default":"delimiter"}}],[/[{}()\[\]<>]/,"@brackets"],[/@symbols/,{cases:{"@operators":"operator","@default":""}}]],whitespace:[[/[ \t\r\n]+/,"white"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\/\*/,"comment","@push"],["\\*/","comment","@pop"],[/[\/*]/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,{token:"string.quote",bracket:"@close",next:"@pop"}]],stringraw:[[/[^"#]+/,{token:"string"}],[/"(#*)/,{cases:{"$1==$S2":{token:"string.quote",bracket:"@close",next:"@pop"},"@default":{token:"string"}}}],[/["#]/,{token:"string"}]],numbers:[[/(0o[0-7_]+)(@intSuffixes)?/,{token:"number"}],[/(0b[0-1_]+)(@intSuffixes)?/,{token:"number"}],[/[\d][\d_]*(\.[\d][\d_]*)?[eE][+-][\d_]+(@floatSuffixes)?/,{token:"number"}],[/\b(\d\.?[\d_]*)(@floatSuffixes)?\b/,{token:"number"}],[/(0x[\da-fA-F]+)_?(@intSuffixes)?/,{token:"number"}],[/[\d][\d_]*(@intSuffixes?)?/,{token:"number"}]]}};return l(m);})();
-return moduleExports;
-});

web/public/vs/basic-languages/sb/sb.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/sb/sb", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var r=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var d=(o,e)=>{for(var t in e)r(o,t,{get:e[t],enumerable:!0})},c=(o,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(o,n)&&n!==t&&r(o,n,{get:()=>e[n],enumerable:!(s=i(e,n))||s.enumerable});return o};var g=o=>c(r({},"__esModule",{value:!0}),o);var m={};d(m,{conf:()=>p,language:()=>f});var p={comments:{lineComment:"'"},brackets:[["(",")"],["[","]"],["If","EndIf"],["While","EndWhile"],["For","EndFor"],["Sub","EndSub"]],autoClosingPairs:[{open:'"',close:'"',notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]}]},f={defaultToken:"",tokenPostfix:".sb",ignoreCase:!0,brackets:[{token:"delimiter.array",open:"[",close:"]"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"keyword.tag-if",open:"If",close:"EndIf"},{token:"keyword.tag-while",open:"While",close:"EndWhile"},{token:"keyword.tag-for",open:"For",close:"EndFor"},{token:"keyword.tag-sub",open:"Sub",close:"EndSub"}],keywords:["Else","ElseIf","EndFor","EndIf","EndSub","EndWhile","For","Goto","If","Step","Sub","Then","To","While"],tagwords:["If","Sub","While","For"],operators:[">","<","<>","<=",">=","And","Or","+","-","*","/","="],identifier:/[a-zA-Z_][\w]*/,symbols:/[=><:+\-*\/%\.,]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[{include:"@whitespace"},[/(@identifier)(?=[.])/,"type"],[/@identifier/,{cases:{"@keywords":{token:"keyword.$0"},"@operators":"operator","@default":"variable.name"}}],[/([.])(@identifier)/,{cases:{$2:["delimiter","type.member"],"@default":""}}],[/\d*\.\d+/,"number.float"],[/\d+/,"number"],[/[()\[\]]/,"@brackets"],[/@symbols/,{cases:{"@operators":"operator","@default":"delimiter"}}],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"]],whitespace:[[/[ \t\r\n]+/,""],[/(\').*$/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"C?/,"string","@pop"]]}};return g(m);})();
-return moduleExports;
-});

web/public/vs/basic-languages/scheme/scheme.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/scheme/scheme", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},m=(o,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of i(e))!l.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(a=r(e,n))||a.enumerable});return o};var p=o=>m(s({},"__esModule",{value:!0}),o);var u={};c(u,{conf:()=>d,language:()=>g});var d={comments:{lineComment:";",blockComment:["#|","|#"]},brackets:[["(",")"],["{","}"],["[","]"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},g={defaultToken:"",ignoreCase:!0,tokenPostfix:".scheme",brackets:[{open:"(",close:")",token:"delimiter.parenthesis"},{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"}],keywords:["case","do","let","loop","if","else","when","cons","car","cdr","cond","lambda","lambda*","syntax-rules","format","set!","quote","eval","append","list","list?","member?","load"],constants:["#t","#f"],operators:["eq?","eqv?","equal?","and","or","not","null?"],tokenizer:{root:[[/#[xXoObB][0-9a-fA-F]+/,"number.hex"],[/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?/,"number.float"],[/(?:\b(?:(define|define-syntax|define-macro))\b)(\s+)((?:\w|\-|\!|\?)*)/,["keyword","white","variable"]],{include:"@whitespace"},{include:"@strings"},[/[a-zA-Z_#][a-zA-Z0-9_\-\?\!\*]*/,{cases:{"@keywords":"keyword","@constants":"constant","@operators":"operators","@default":"identifier"}}]],comment:[[/[^\|#]+/,"comment"],[/#\|/,"comment","@push"],[/\|#/,"comment","@pop"],[/[\|#]/,"comment"]],whitespace:[[/[ \t\r\n]+/,"white"],[/#\|/,"comment","@comment"],[/;.*$/,"comment"]],strings:[[/"$/,"string","@popall"],[/"(?=.)/,"string","@multiLineString"]],multiLineString:[[/[^\\"]+$/,"string","@popall"],[/[^\\"]+/,"string"],[/\\./,"string.escape"],[/"/,"string","@popall"],[/\\$/,"string"]]}};return p(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/scss/scss.js

@@ -1,12 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/scss/scss", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var o in e)i(t,o,{get:e[o],enumerable:!0})},m=(t,e,o,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of l(e))!d.call(t,n)&&n!==o&&i(t,n,{get:()=>e[n],enumerable:!(r=a(e,n))||r.enumerable});return t};var s=t=>m(i({},"__esModule",{value:!0}),t);var k={};c(k,{conf:()=>u,language:()=>p});var u={wordPattern:/(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,comments:{blockComment:["/*","*/"],lineComment:"//"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),end:new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")}}},p={defaultToken:"",tokenPostfix:".scss",ws:`[ 	
-\r\f]*`,identifier:"-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],tokenizer:{root:[{include:"@selector"}],selector:[{include:"@comments"},{include:"@import"},{include:"@variabledeclaration"},{include:"@warndebug"},["[@](include)",{token:"keyword",next:"@includedeclaration"}],["[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",{token:"keyword",next:"@keyframedeclaration"}],["[@](page|content|font-face|-moz-document)",{token:"keyword"}],["[@](charset|namespace)",{token:"keyword",next:"@declarationbody"}],["[@](function)",{token:"keyword",next:"@functiondeclaration"}],["[@](mixin)",{token:"keyword",next:"@mixindeclaration"}],["url(\\-prefix)?\\(",{token:"meta",next:"@urldeclaration"}],{include:"@controlstatement"},{include:"@selectorname"},["[&\\*]","tag"],["[>\\+,]","delimiter"],["\\[",{token:"delimiter.bracket",next:"@selectorattribute"}],["{",{token:"delimiter.curly",next:"@selectorbody"}]],selectorbody:[["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))","attribute.name","@rulevalue"],{include:"@selector"},["[@](extend)",{token:"keyword",next:"@extendbody"}],["[@](return)",{token:"keyword",next:"@declarationbody"}],["}",{token:"delimiter.curly",next:"@pop"}]],selectorname:[["#{",{token:"meta",next:"@variableinterpolation"}],["(\\.|#(?=[^{])|%|(@identifier)|:)+","tag"]],selectorattribute:[{include:"@term"},["]",{token:"delimiter.bracket",next:"@pop"}]],term:[{include:"@comments"},["url(\\-prefix)?\\(",{token:"meta",next:"@urldeclaration"}],{include:"@functioninvocation"},{include:"@numbers"},{include:"@strings"},{include:"@variablereference"},["(and\\b|or\\b|not\\b)","operator"],{include:"@name"},["([<>=\\+\\-\\*\\/\\^\\|\\~,])","operator"],[",","delimiter"],["!default","literal"],["\\(",{token:"delimiter.parenthesis",next:"@parenthizedterm"}]],rulevalue:[{include:"@term"},["!important","literal"],[";","delimiter","@pop"],["{",{token:"delimiter.curly",switchTo:"@nestedproperty"}],["(?=})",{token:"",next:"@pop"}]],nestedproperty:[["[*_]?@identifier@ws:","attribute.name","@rulevalue"],{include:"@comments"},["}",{token:"delimiter.curly",next:"@pop"}]],warndebug:[["[@](warn|debug)",{token:"keyword",next:"@declarationbody"}]],import:[["[@](import)",{token:"keyword",next:"@declarationbody"}]],variabledeclaration:[["\\$@identifier@ws:","variable.decl","@declarationbody"]],urldeclaration:[{include:"@strings"},[`[^)\r
-]+`,"string"],["\\)",{token:"meta",next:"@pop"}]],parenthizedterm:[{include:"@term"},["\\)",{token:"delimiter.parenthesis",next:"@pop"}]],declarationbody:[{include:"@term"},[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],extendbody:[{include:"@selectorname"},["!optional","literal"],[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],variablereference:[["\\$@identifier","variable.ref"],["\\.\\.\\.","operator"],["#{",{token:"meta",next:"@variableinterpolation"}]],variableinterpolation:[{include:"@variablereference"},["}",{token:"meta",next:"@pop"}]],comments:[["\\/\\*","comment","@comment"],["\\/\\/+.*","comment"]],comment:[["\\*\\/","comment","@pop"],[".","comment"]],name:[["@identifier","attribute.value"]],numbers:[["(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?",{token:"number",next:"@units"}],["#[0-9a-fA-F_]+(?!\\w)","number.hex"]],units:[["(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?","number","@pop"]],functiondeclaration:[["@identifier@ws\\(",{token:"meta",next:"@parameterdeclaration"}],["{",{token:"delimiter.curly",switchTo:"@functionbody"}]],mixindeclaration:[["@identifier@ws\\(",{token:"meta",next:"@parameterdeclaration"}],["@identifier","meta"],["{",{token:"delimiter.curly",switchTo:"@selectorbody"}]],parameterdeclaration:[["\\$@identifier@ws:","variable.decl"],["\\.\\.\\.","operator"],[",","delimiter"],{include:"@term"},["\\)",{token:"meta",next:"@pop"}]],includedeclaration:[{include:"@functioninvocation"},["@identifier","meta"],[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}],["{",{token:"delimiter.curly",switchTo:"@selectorbody"}]],keyframedeclaration:[["@identifier","meta"],["{",{token:"delimiter.curly",switchTo:"@keyframebody"}]],keyframebody:[{include:"@term"},["{",{token:"delimiter.curly",next:"@selectorbody"}],["}",{token:"delimiter.curly",next:"@pop"}]],controlstatement:[["[@](if|else|for|while|each|media)",{token:"keyword.flow",next:"@controlstatementdeclaration"}]],controlstatementdeclaration:[["(in|from|through|if|to)\\b",{token:"keyword.flow"}],{include:"@term"},["{",{token:"delimiter.curly",switchTo:"@selectorbody"}]],functionbody:[["[@](return)",{token:"keyword"}],{include:"@variabledeclaration"},{include:"@term"},{include:"@controlstatement"},[";","delimiter"],["}",{token:"delimiter.curly",next:"@pop"}]],functioninvocation:[["@identifier\\(",{token:"meta",next:"@functionarguments"}]],functionarguments:[["\\$@identifier@ws:","attribute.name"],["[,]","delimiter"],{include:"@term"},["\\)",{token:"meta",next:"@pop"}]],strings:[['~?"',{token:"string.delimiter",next:"@stringenddoublequote"}],["~?'",{token:"string.delimiter",next:"@stringendquote"}]],stringenddoublequote:[["\\\\.","string"],['"',{token:"string.delimiter",next:"@pop"}],[".","string"]],stringendquote:[["\\\\.","string"],["'",{token:"string.delimiter",next:"@pop"}],[".","string"]]}};return s(k);})();
-return moduleExports;
-});

web/public/vs/basic-languages/shell/shell.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/shell/shell", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var a=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(r,e)=>{for(var i in e)a(r,i,{get:e[i],enumerable:!0})},d=(r,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of n(e))!l.call(r,t)&&t!==i&&a(r,t,{get:()=>e[t],enumerable:!(o=s(e,t))||o.enumerable});return r};var p=r=>d(a({},"__esModule",{value:!0}),r);var g={};c(g,{conf:()=>m,language:()=>u});var m={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"`",close:"`"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"`",close:"`"}]},u={defaultToken:"",ignoreCase:!0,tokenPostfix:".shell",brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"}],keywords:["if","then","do","else","elif","while","until","for","in","esac","fi","fin","fil","done","exit","set","unset","export","function"],builtins:["ab","awk","bash","beep","cat","cc","cd","chown","chmod","chroot","clear","cp","curl","cut","diff","echo","find","gawk","gcc","get","git","grep","hg","kill","killall","ln","ls","make","mkdir","openssl","mv","nc","node","npm","ping","ps","restart","rm","rmdir","sed","service","sh","shopt","shred","source","sort","sleep","ssh","start","stop","su","sudo","svn","tee","telnet","top","touch","vi","vim","wall","wc","wget","who","write","yes","zsh"],startingWithDash:/\-+\w+/,identifiersWithDashes:/[a-zA-Z]\w+(?:@startingWithDash)+/,symbols:/[=><!~?&|+\-*\/\^;\.,]+/,tokenizer:{root:[[/@identifiersWithDashes/,""],[/(\s)((?:@startingWithDash)+)/,["white","attribute.name"]],[/[a-zA-Z]\w*/,{cases:{"@keywords":"keyword","@builtins":"type.identifier","@default":""}}],{include:"@whitespace"},{include:"@strings"},{include:"@parameters"},{include:"@heredoc"},[/[{}\[\]()]/,"@brackets"],[/@symbols/,"delimiter"],{include:"@numbers"},[/[,;]/,"delimiter"]],whitespace:[[/\s+/,"white"],[/(^#!.*$)/,"metatag"],[/(^#.*$)/,"comment"]],numbers:[[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+/,"number"]],strings:[[/'/,"string","@stringBody"],[/"/,"string","@dblStringBody"]],stringBody:[[/'/,"string","@popall"],[/./,"string"]],dblStringBody:[[/"/,"string","@popall"],[/./,"string"]],heredoc:[[/(<<[-<]?)(\s*)(['"`]?)([\w\-]+)(['"`]?)/,["constants","white","string.heredoc.delimiter","string.heredoc","string.heredoc.delimiter"]]],parameters:[[/\$\d+/,"variable.predefined"],[/\$\w+/,"variable"],[/\$[*@#?\-$!0_]/,"variable"],[/\$'/,"variable","@parameterBodyQuote"],[/\$"/,"variable","@parameterBodyDoubleQuote"],[/\$\(/,"variable","@parameterBodyParen"],[/\$\{/,"variable","@parameterBodyCurlyBrace"]],parameterBodyQuote:[[/[^#:%*@\-!_']+/,"variable"],[/[#:%*@\-!_]/,"delimiter"],[/[']/,"variable","@pop"]],parameterBodyDoubleQuote:[[/[^#:%*@\-!_"]+/,"variable"],[/[#:%*@\-!_]/,"delimiter"],[/["]/,"variable","@pop"]],parameterBodyParen:[[/[^#:%*@\-!_)]+/,"variable"],[/[#:%*@\-!_]/,"delimiter"],[/[)]/,"variable","@pop"]],parameterBodyCurlyBrace:[[/[^#:%*@\-!_}]+/,"variable"],[/[#:%*@\-!_]/,"delimiter"],[/[}]/,"variable","@pop"]]}};return p(g);})();
-return moduleExports;
-});

web/public/vs/basic-languages/sophia/sophia.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/sophia/sophia", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},m=(t,e,o,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!c.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(r=i(e,n))||r.enumerable});return t};var d=t=>m(s({},"__esModule",{value:!0}),t);var u={};l(u,{conf:()=>f,language:()=>g});var f={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"],["<",">"]],autoClosingPairs:[{open:'"',close:'"',notIn:["string","comment"]},{open:"{",close:"}",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]}]},g={defaultToken:"",tokenPostfix:".aes",brackets:[{token:"delimiter.curly",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"},{token:"delimiter.angle",open:"<",close:">"}],keywords:["contract","library","entrypoint","function","stateful","state","hash","signature","tuple","list","address","string","bool","int","record","datatype","type","option","oracle","oracle_query","Call","Bits","Bytes","Oracle","String","Crypto","Address","Auth","Chain","None","Some","bits","bytes","event","let","map","private","public","true","false","var","if","else","throw"],operators:["=",">","<","!","~","?","::",":","==","<=",">=","!=","&&","||","++","--","+","-","*","/","&","|","^","%","<<",">>",">>>","+=","-=","*=","/=","&=","|=","^=","%=","<<=",">>=",">>>="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,integersuffix:/(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,floatsuffix:/[fFlL]?/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/\[\[.*\]\]/,"annotation"],[/^\s*#\w+/,"keyword"],[/int\d*/,"keyword"],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/,"number.float"],[/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/,"number.hex"],[/0[0-7']*[0-7](@integersuffix)/,"number.octal"],[/0[bB][0-1']*[0-1](@integersuffix)/,"number.binary"],[/\d[\d']*\d(@integersuffix)/,"number"],[/\d(@integersuffix)/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@doccomment"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],doccomment:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]]}};return d(u);})();
-return moduleExports;
-});

web/public/vs/basic-languages/sparql/sparql.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/sparql/sparql", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var o=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var d=(s,e)=>{for(var n in e)o(s,n,{get:e[n],enumerable:!0})},c=(s,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!l.call(s,t)&&t!==n&&o(s,t,{get:()=>e[t],enumerable:!(r=i(e,t))||r.enumerable});return s};var g=s=>c(o({},"__esModule",{value:!0}),s);var m={};d(m,{conf:()=>u,language:()=>p});var u={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"'",close:"'",notIn:["string"]},{open:'"',close:'"',notIn:["string"]},{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"}]},p={defaultToken:"",tokenPostfix:".rq",brackets:[{token:"delimiter.curly",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"},{token:"delimiter.angle",open:"<",close:">"}],keywords:["add","as","asc","ask","base","by","clear","construct","copy","create","data","delete","desc","describe","distinct","drop","false","filter","from","graph","group","having","in","insert","limit","load","minus","move","named","not","offset","optional","order","prefix","reduced","select","service","silent","to","true","undef","union","using","values","where","with"],builtinFunctions:["a","abs","avg","bind","bnode","bound","ceil","coalesce","concat","contains","count","datatype","day","encode_for_uri","exists","floor","group_concat","hours","if","iri","isblank","isiri","isliteral","isnumeric","isuri","lang","langmatches","lcase","max","md5","min","minutes","month","now","rand","regex","replace","round","sameterm","sample","seconds","sha1","sha256","sha384","sha512","str","strafter","strbefore","strdt","strends","strlang","strlen","strstarts","struuid","substr","sum","timezone","tz","ucase","uri","uuid","year"],ignoreCase:!0,tokenizer:{root:[[/<[^\s\u00a0>]*>?/,"tag"],{include:"@strings"},[/#.*/,"comment"],[/[{}()\[\]]/,"@brackets"],[/[;,.]/,"delimiter"],[/[_\w\d]+:(\.(?=[\w_\-\\%])|[:\w_-]|\\[-\\_~.!$&'()*+,;=/?#@%]|%[a-f\d][a-f\d])*/,"tag"],[/:(\.(?=[\w_\-\\%])|[:\w_-]|\\[-\\_~.!$&'()*+,;=/?#@%]|%[a-f\d][a-f\d])+/,"tag"],[/[$?]?[_\w\d]+/,{cases:{"@keywords":{token:"keyword"},"@builtinFunctions":{token:"predefined.sql"},"@default":"identifier"}}],[/\^\^/,"operator.sql"],[/\^[*+\-<>=&|^\/!?]*/,"operator.sql"],[/[*+\-<>=&|\/!?]/,"operator.sql"],[/@[a-z\d\-]*/,"metatag.html"],[/\s+/,"white"]],strings:[[/'([^'\\]|\\.)*$/,"string.invalid"],[/'$/,"string.sql","@pop"],[/'/,"string.sql","@stringBody"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"$/,"string.sql","@pop"],[/"/,"string.sql","@dblStringBody"]],stringBody:[[/[^\\']+/,"string.sql"],[/\\./,"string.escape"],[/'/,"string.sql","@pop"]],dblStringBody:[[/[^\\"]+/,"string.sql"],[/\\./,"string.escape"],[/"/,"string.sql","@pop"]]}};return g(m);})();
-return moduleExports;
-});

web/public/vs/basic-languages/tcl/tcl.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/tcl/tcl", ["require","require"],(require)=>{
-"use strict";var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var o in e)s(t,o,{get:e[o],enumerable:!0})},p=(t,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(t,n)&&n!==o&&s(t,n,{get:()=>e[n],enumerable:!(i=r(e,n))||i.enumerable});return t};var u=t=>p(s({},"__esModule",{value:!0}),t);var g={};c(g,{conf:()=>k,language:()=>d});var k={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},d={tokenPostfix:".tcl",specialFunctions:["set","unset","rename","variable","proc","coroutine","foreach","incr","append","lappend","linsert","lreplace"],mainFunctions:["if","then","elseif","else","case","switch","while","for","break","continue","return","package","namespace","catch","exit","eval","expr","uplevel","upvar"],builtinFunctions:["file","info","concat","join","lindex","list","llength","lrange","lsearch","lsort","split","array","parray","binary","format","regexp","regsub","scan","string","subst","dict","cd","clock","exec","glob","pid","pwd","close","eof","fblocked","fconfigure","fcopy","fileevent","flush","gets","open","puts","read","seek","socket","tell","interp","after","auto_execok","auto_load","auto_mkindex","auto_reset","bgerror","error","global","history","load","source","time","trace","unknown","unset","update","vwait","winfo","wm","bind","event","pack","place","grid","font","bell","clipboard","destroy","focus","grab","lower","option","raise","selection","send","tk","tkwait","tk_bisque","tk_focusNext","tk_focusPrev","tk_focusFollowsMouse","tk_popup","tk_setPalette"],symbols:/[=><!~?:&|+\-*\/\^%]+/,brackets:[{open:"(",close:")",token:"delimiter.parenthesis"},{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"}],escapes:/\\(?:[abfnrtv\\"'\[\]\{\};\$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,variables:/(?:\$+(?:(?:\:\:?)?[a-zA-Z_]\w*)+)/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@specialFunctions":{token:"keyword.flow",next:"@specialFunc"},"@mainFunctions":"keyword","@builtinFunctions":"variable","@default":"operator.scss"}}],[/\s+\-+(?!\d|\.)\w*|{\*}/,"metatag"],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/@symbols/,"operator"],[/\$+(?:\:\:)?\{/,{token:"identifier",next:"@nestedVariable"}],[/@variables/,"type.identifier"],[/\.(?!\d|\.)[\w\-]*/,"operator.sql"],[/\d+(\.\d+)?/,"number"],[/\d+/,"number"],[/;/,"delimiter"],[/"/,{token:"string.quote",bracket:"@open",next:"@dstring"}],[/'/,{token:"string.quote",bracket:"@open",next:"@sstring"}]],dstring:[[/\[/,{token:"@brackets",next:"@nestedCall"}],[/\$+(?:\:\:)?\{/,{token:"identifier",next:"@nestedVariable"}],[/@variables/,"type.identifier"],[/[^\\$\[\]"]+/,"string"],[/@escapes/,"string.escape"],[/"/,{token:"string.quote",bracket:"@close",next:"@pop"}]],sstring:[[/\[/,{token:"@brackets",next:"@nestedCall"}],[/\$+(?:\:\:)?\{/,{token:"identifier",next:"@nestedVariable"}],[/@variables/,"type.identifier"],[/[^\\$\[\]']+/,"string"],[/@escapes/,"string.escape"],[/'/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"],[/#.*\\$/,{token:"comment",next:"@newlineComment"}],[/#.*(?!\\)$/,"comment"]],newlineComment:[[/.*\\$/,"comment"],[/.*(?!\\)$/,{token:"comment",next:"@pop"}]],nestedVariable:[[/[^\{\}\$]+/,"type.identifier"],[/\}/,{token:"identifier",next:"@pop"}]],nestedCall:[[/\[/,{token:"@brackets",next:"@nestedCall"}],[/\]/,{token:"@brackets",next:"@pop"}],{include:"root"}],specialFunc:[[/"/,{token:"string",next:"@dstring"}],[/'/,{token:"string",next:"@sstring"}],[/\S+/,{token:"type",next:"@pop"}]]}};return u(g);})();
-return moduleExports;
-});