Upload 62 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+paper.pdf filter=lfs diff=lfs merge=lfs -text
+test.wav filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abdullah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PKG-INFO

@@ -0,0 +1,357 @@
+Metadata-Version: 2.4
+Name: quran-muaalem
+Version: 0.0.3
+Summary: Quran Phonetic Script with addional quarnic utils
+Author-email: Abdullah <abdullahamlyossef@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/obadx/quran-muaalem
+Project-URL: Issues, https://github.com/obadx/quran-muaalem/issues
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: quran-transcript>=0.1.0
+Requires-Dist: rich>=14.1.0
+Requires-Dist: torch>=2.7.0
+Requires-Dist: transformers>=4.55.0
+Provides-Extra: test
+Requires-Dist: librosa>=0.11.0; extra == "test"
+Requires-Dist: numba>=0.61.2; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: ui
+Requires-Dist: gradio>=5.43.1; extra == "ui"
+Requires-Dist: librosa>=0.11.0; extra == "ui"
+Requires-Dist: numba>=0.61.2; extra == "ui"
+Requires-Dist: moviepy>=2.2.1; extra == "ui"
+Dynamic: license-file
+
+# Quran Muaalem
+
+<div align="center">
+<strong>بعون الله وتوفيقه لا شريك له نقدم المعلم القرآني الذكي القادر على كشف أخطاء التلاوة والتجويد وصفات الحروف</strong>
+
+[![PyPI][pypi-badge]][pypi-url]
+[![Python Versions][python-badge]][python-url]
+[![Hugging Face Model][hf-model-badge]][hf-model-url]
+[![Hugging Face Dataset][hf-dataset-badge]][hf-dataset-url]
+[![Google Colab][colab-badge]][colab-url]
+[![arXiv][arxiv-badge]][arxiv-url]
+[![MIT License][mit-badge]][mit-url]
+[![Discord][discord-badge]][discord-url]
+
+</div>
+
+[pypi-badge]: https://img.shields.io/pypi/v/quran-muaalem.svg
+[pypi-url]: https://pypi.org/project/quran-muaalem/
+[mit-badge]: https://img.shields.io/github/license/obadx/quran-muaalem.svg
+[mit-url]: https://github.com/obadx/quran-muaalem/blob/main/LICENSE
+[python-badge]: https://img.shields.io/pypi/pyversions/quran-muaalem.svg
+[python-url]: https://pypi.org/project/quran-muaalem/
+[colab-badge]: https://img.shields.io/badge/Google%20Colab-Open%20in%20Colab-F9AB00?logo=google-colab&logoColor=white
+[colab-url]: https://colab.research.google.com/drive/1If0G9NtdXiSRu6PVGtIMvLwxizF2jspn?usp=sharing
+[hf-model-badge]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-blue
+[hf-model-url]: https://huggingface.co/obadx/muaalem-model-v3_0
+[hf-dataset-badge]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Dataset-orange
+[hf-dataset-url]: https://huggingface.co/datasets/obadx/muaalem-annotated-v3
+[arxiv-badge]: https://img.shields.io/badge/arXiv-Paper-<COLOR>.svg
+[arxiv-url]: https://arxiv.org/abs/2509.00094
+[discord-badge]: https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white
+[discord-url]: https://discord.gg/hJWW6fCH
+
+<div align="center" style="background-color: #f0f8ff; border-left: 5px solid #4CAF50; padding: 15px; margin: 20px 0; border-radius: 5px;">
+  <h3 style="color: #2c3e50; margin-top: 0;">📖 رابط لتجربة المعلم القرآني</h3>
+  <p style="margin: 10px 0;">يرجى الضغط على للتجربة:</p>
+  <a href="https://662a040e1863a5445c.gradio.live" style="display: inline-block; background-color: #4CAF50; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; font-weight: bold; margin: 10px 0;">الرابط</a>
+  <p style="background-color: #ffeb3b; padding: 8px; border-radius: 3px; display: inline-block; margin: 10px 0;">
+    ⚠️ <strong>تنبيه:</strong> هذا الرابط سينتهي في <span style="color: #d32f2f; font-weight: bold;">27 أغسطس 2025</span>
+  </p>
+</div>
+
+[![ALT_TEXT](https://img.youtube.com/vi/CsFoznO08-Q/0.jpg)](https://www.youtube.com/watch?v=CsFoznO08-Q)
+
+
+## الممزيات
+
+* مدرب على الرسم الصوتي للقرآن الكريم: [quran-transcript](https://github.com/obadx/quran-transcript) القادر على كشف أخطاء الحروف والتجويد وصفات الحروف
+* نموذج معقول الحجم 660 MP 
+* يحتاج فقط إله 1.5 GB من ذاكرة معالج الرسوميات
+* معمارية مبتكرة: CTC متعدد المستويات
+
+## المعمارية
+معمارية مبتكرة: CTC متعدد المستويات. حيث كل مستوي يتدرب على وجه معين
+
+![multi-lvel-ctc](./assets/figures/mutli-level-ctc.png)
+
+## الخطوات المختصرة للتطوير
+
+* تجميع التلاوت القرآنية من القراء المتقنين: [prepare-quran-dataset](https://github.com/obadx/prepare-quran-dataset)
+* تقسيم التلاوت على حسب الوقف وليس الآية باستخدام [المقسم](https://github.com/obadx/recitations-segmenter)
+* الحصو على النص القرآني من المقاطع الصوتية باسخدام [نموذج ترتيل](https://huggingface.co/tarteel-ai/whisper-base-ar-quran)
+* تصحيح النصوص المستخرجة من ترتيل باستخدام  [خوارزمية التسميع](https://github.com/obadx/quran-transcript)
+* تحويل الرسم الإملائي للرسم العثماني: [quran-transcript](https://github.com/obadx/quran-transcript)
+* تحويل الرسم العثماني للرسم الصوتي للقرآني الكريم الذي يصف كل قواعد التجويد ما عدا الإشمام: [quran-transcript](https://github.com/obadx/quran-transcript)
+* تدريب النموذج على معمارية [Wav2Vec2BERT](https://huggingface.co/docs/transformers/model_doc/wav2vec2-bert)
+
+
+## استخدام النوذج
+
+
+### استخدام النموذج عن طريق واجهة gradio
+
+قم بتزيل  [uv](https://docs.astral.sh/uv/) 
+
+```bash
+pip install uv
+```
+أو
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+بعد ذلك قم بتنزيل `ffmpeg`
+
+```bash
+sudo apt-get update
+sudo apt-get install -y ffmpeg
+```
+
+أو من خلال `anaconda`
+```bash
+conda install ffmpeg
+```
+
+قم بتشغيل `gradio` ب command واحد فقط:
+```bash
+uvx --no-cache --from https://github.com/obadx/quran-muaalem.git[ui]  quran-muaalem-ui
+```
+او
+```bash
+uvx quran-muaalem[ui]  quran-muaalem-ui
+```
+
+### عن طريق python API
+
+
+#### Installation
+
+First, install the required dependencies:
+
+```bash
+# Install system dependencies
+sudo apt-get install -y ffmpeg libsndfile1 portaudio19-dev
+
+# Install Python packages
+pip install quran-muaalem librosa "numba>=0.61.2"
+```
+
+## Basic Usage Example
+
+```python
+"""
+Basic example of using the Quran Muaalem package for phonetic analysis of Quranic recitation.
+"""
+
+from dataclasses import asdict
+import json
+import logging
+
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+import torch
+from librosa.core import load
+
+# Import the main Muaalem class (adjust import based on your actual package structure)
+from quran_muaalem import Muaalem
+
+# Setup logging to see informative messages
+logging.basicConfig(level=logging.INFO)
+
+def analyze_recitation(audio_path):
+    """
+    Analyze a Quranic recitation audio file using the Muaalem model.
+    
+    Args:
+        audio_path (str): Path to the audio file to analyze
+    """
+    # Configuration
+    sampling_rate = 16000  # Must be 16000 Hz
+    device = "cuda" if torch.cuda.is_available() else "cpu"  # Use GPU if available
+    
+    # Step 1: Prepare the Quranic reference text
+    # Get the Uthmani script for a specific verse (Aya 8, Surah 75 in this example)
+    uthmani_ref = Aya(8, 75).get_by_imlaey_words(17, 9).uthmani
+    
+    # Step 2: Configure the recitation style (Moshaf attributes)
+    moshaf = MoshafAttributes(
+        rewaya="hafs",        # Recitation style (Hafs is most common)
+        madd_monfasel_len=2,  # Length of separated elongation
+        madd_mottasel_len=4,  # Length of connected elongation
+        madd_mottasel_waqf=4, # Length of connected elongation when stopping
+        madd_aared_len=2,     # Length of necessary elongation
+    )
+    # see: https://github.com/obadx/prepare-quran-dataset?tab=readme-ov-file#moshaf-attributes-docs
+    
+    # Step 3: Convert text to phonetic representation
+    # see docs for phnetizer: https://github.com/obadx/quran-transcript
+    phonetizer_out = quran_phonetizer(uthmani_ref, moshaf, remove_spaces=True)
+    
+    # Step 4: Initialize the Muaalem model
+    muaalem = Muaalem(device=device)
+    
+    # Step 5: Load and prepare the audio
+    wave, _ = load(audio_path, sr=sampling_rate, mono=True)
+    
+    # Step 6: Process the audio with the model
+    # The model analyzes the phonetic properties of the recitation
+    outs = muaalem(
+        [wave],           # Audio data
+        [phonetizer_out],          # Phonetic reference
+        sampling_rate=sampling_rate
+    )
+    
+    # Step 7: Display the results
+    for out in outs:
+        print("Predicted Phonemes:", out.phonemes.text)
+        
+        # Display detailed phonetic features for each phoneme
+        for sifa in out.sifat:
+            print(json.dumps(asdict(sifa), indent=2, ensure_ascii=False))
+            print("*" * 30)
+        print("-" * 40)
+
+    # Explaining Results
+    explain_for_terminal(
+        outs[0].phonemes.text,
+        phonetizer_out.phonemes,
+        outs[0].sifat,
+        phonetizer_out.sifat,
+    )
+
+
+if __name__ == "__main__":
+    # Replace with the path to your audio file
+    audio_path = "./assets/test.wav"
+    
+    try:
+        analyze_recitation(audio_path)
+    except Exception as e:
+        logging.error(f"Error processing audio: {e}")
+```
+
+Output:
+
+```bash
+ءِننننَللَااهَبِكُللِشَيءِنعَلِۦۦمُ۾۾۾بَرَااااءَتُممممِنَللَااهِوَرَسُۥۥلِه
+┏━━━━━━━━━━┳━━━━━��━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┓
+┃ Phonemes ┃ Tafashie       ┃ Qalqla       ┃ Ghonna       ┃ Hams Or Jahr ┃ Safeer    ┃ Tikraar     ┃ Tafkheem Or Taqeeq ┃ Istitala      ┃ Shidda Or Rakhawa ┃ Itbaq    ┃
+┡━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━┩
+│ ءِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ننننَ     │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ للَ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اا       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ هَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ بِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ كُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ للِ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ شَ        │ motafashie     │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ي        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ءِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ن        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ عَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ لِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ۦۦ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ مُ        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ۾۾۾      │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ بَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ رَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ mokarar     │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اااا     │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ ءَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ تُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ممممِ     │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ نَ        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ للَ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اا       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ هِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ وَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ رَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ mokarar     │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ سُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ safeer    │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ۥۥ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ لِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ه        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+└──────────┴────────────────┴──────────────┴──────────────┴──────────────┴───────────┴─────────────┴────────────────────┴───────────────┴───────────────────┴──────────┘
+```
+
+### API Docs
+
+```python
+class Muaalem:
+    def __init__(
+        self,
+        model_name_or_path: str = "obadx/muaalem-model-v3_2",
+        device: str = "cpu",
+        dtype=torch.bfloat16,
+    ):
+        """
+        Initializing Muallem Model
+
+        Args:
+            model_name_or_path: the huggingface model name or path
+            device: the device to run model on
+            dtype: the torch dtype. Default is `torch.bfloat16` as the model was trained on
+        """
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        waves: list[list[float] | torch.FloatTensor | NDArray],
+        ref_quran_phonetic_script_list: list[QuranPhoneticScriptOutput],
+        sampling_rate: int,
+    ) -> list[MuaalemOutput]:
+        """Infrence Funcion for the Quran Muaalem Project
+
+                waves: input waves  batch , seq_len with different formats described above
+                ref_quran_phonetic_script_list (list[QuranPhoneticScriptOutput]): list of the
+                    phonetized ouput of `quran_transcript.quran_phonetizer` with `remove_space=True`
+
+                sampleing_rate (int): has to be 16000
+
+        Returns:
+            list[MuaalemOutput]:
+                A list of output objects, each containing phoneme predictions and their
+                phonetic features (sifat) for a processed input.
+
+            Each MuaalemOutput contains:
+                phonemes (Unit):
+                    A dataclass representing the predicted phoneme sequence with:
+                        text (str): Concatenated string of all phonemes.
+                        probs (Union[torch.FloatTensor, list[float]]):
+                            Confidence probabilities for each predicted phoneme.
+                        ids (Union[torch.LongTensor, list[int]]):
+                            Token IDs corresponding to each phoneme.
+
+                sifat (list[Sifa]):
+                    A list of phonetic feature dataclasses (one per phoneme) with the
+                    following optional properties (each is a SingleUnit or None):
+                        - phonemes_group (str): the phonemes associated with the `sifa`
+                        - hams_or_jahr (SingleUnit): either `hams` or `jahr`
+                        - shidda_or_rakhawa (SingleUnit): either `shadeed`, `between`, or `rikhw`
+                        - tafkheem_or_taqeeq (SingleUnit): either `mofakham`, `moraqaq`, or `low_mofakham`
+                        - itbaq (SingleUnit): either `monfateh`, or `motbaq`
+                        - safeer (SingleUnit): either `safeer`, or `no_safeer`
+                        - qalqla (SingleUnit): eithr `moqalqal`, or `not_moqalqal`
+                        - tikraar (SingleUnit): either `mokarar` or `not_mokarar`
+                        - tafashie (SingleUnit): either `motafashie`, or `not_motafashie`
+                        - istitala (SingleUnit): either `mostateel`, or `not_mostateel`
+                        - ghonna (SingleUnit): either `maghnoon`, or `not_maghnoon`
+
+            Each SingleUnit in Sifa properties contains:
+                text (str): The feature's categorical label (e.g., "hams", "shidda").
+                prob (float): Confidence probability for this feature.
+                idx (int): Identifier for the feature class.
+        """
+```

README.md

@@ -1,13 +1,324 @@
----
-title: Youssef
-emoji: 🚀
-colorFrom: green
-colorTo: pink
-sdk: gradio
-sdk_version: 6.4.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Quran Muaalem
+
+<div align="center">
+<strong>بعون الله وتوفيقه لا شريك له نقدم المعلم القرآني الذكي القادر على كشف أخطاء التلاوة والتجويد وصفات الحروف</strong>
+
+[![PyPI][pypi-badge]][pypi-url]
+[![Python Versions][python-badge]][python-url]
+[![Hugging Face Model][hf-model-badge]][hf-model-url]
+[![Hugging Face Dataset][hf-dataset-badge]][hf-dataset-url]
+[![Google Colab][colab-badge]][colab-url]
+[![arXiv][arxiv-badge]][arxiv-url]
+[![MIT License][mit-badge]][mit-url]
+[![Discord][discord-badge]][discord-url]
+
+</div>
+
+[pypi-badge]: https://img.shields.io/pypi/v/quran-muaalem.svg
+[pypi-url]: https://pypi.org/project/quran-muaalem/
+[mit-badge]: https://img.shields.io/github/license/obadx/quran-muaalem.svg
+[mit-url]: https://github.com/obadx/quran-muaalem/blob/main/LICENSE
+[python-badge]: https://img.shields.io/pypi/pyversions/quran-muaalem.svg
+[python-url]: https://pypi.org/project/quran-muaalem/
+[colab-badge]: https://img.shields.io/badge/Google%20Colab-Open%20in%20Colab-F9AB00?logo=google-colab&logoColor=white
+[colab-url]: https://colab.research.google.com/drive/1If0G9NtdXiSRu6PVGtIMvLwxizF2jspn?usp=sharing
+[hf-model-badge]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-blue
+[hf-model-url]: https://huggingface.co/obadx/muaalem-model-v3_0
+[hf-dataset-badge]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Dataset-orange
+[hf-dataset-url]: https://huggingface.co/datasets/obadx/muaalem-annotated-v3
+[arxiv-badge]: https://img.shields.io/badge/arXiv-Paper-<COLOR>.svg
+[arxiv-url]: https://arxiv.org/abs/2509.00094
+[discord-badge]: https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white
+[discord-url]: https://discord.gg/hJWW6fCH
+
+<div align="center" style="background-color: #f0f8ff; border-left: 5px solid #4CAF50; padding: 15px; margin: 20px 0; border-radius: 5px;">
+  <h3 style="color: #2c3e50; margin-top: 0;">📖 رابط لتجربة المعلم القرآني</h3>
+  <p style="margin: 10px 0;">يرجى الضغط على للتجربة:</p>
+  <a href="https://662a040e1863a5445c.gradio.live" style="display: inline-block; background-color: #4CAF50; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; font-weight: bold; margin: 10px 0;">الرابط</a>
+  <p style="background-color: #ffeb3b; padding: 8px; border-radius: 3px; display: inline-block; margin: 10px 0;">
+    ⚠️ <strong>تنبيه:</strong> هذا الرابط سينتهي في <span style="color: #d32f2f; font-weight: bold;">27 أغسطس 2025</span>
+  </p>
+</div>
+
+[![ALT_TEXT](https://img.youtube.com/vi/CsFoznO08-Q/0.jpg)](https://www.youtube.com/watch?v=CsFoznO08-Q)
+
+
+## الممزيات
+
+* مدرب على الرسم الصوتي للقرآن الكريم: [quran-transcript](https://github.com/obadx/quran-transcript) القادر على كشف أخطاء الحروف والتجويد وصفات الحروف
+* نموذج معقول الحجم 660 MP 
+* يحتاج فقط إله 1.5 GB من ذاكرة معالج الرسوميات
+* معمارية مبتكرة: CTC متعدد المستويات
+
+## المعمارية
+معمارية مبتكرة: CTC متعدد المستويات. حيث كل مستوي يتدرب على وجه معين
+
+![multi-lvel-ctc](./assets/figures/mutli-level-ctc.png)
+
+## الخطوات المختصرة للتطوير
+
+* تجميع التلاوت القرآنية من القراء المتقنين: [prepare-quran-dataset](https://github.com/obadx/prepare-quran-dataset)
+* تقسيم التلاوت على حسب الوقف وليس الآية باستخدام [المقسم](https://github.com/obadx/recitations-segmenter)
+* الحصو على النص القرآني من المقاطع الصوتية باسخدام [نموذج ترتيل](https://huggingface.co/tarteel-ai/whisper-base-ar-quran)
+* تصحيح النصوص المستخرجة من ترتيل باستخدام  [خوارزمية التسميع](https://github.com/obadx/quran-transcript)
+* تحويل الرسم الإملائي للرسم العثماني: [quran-transcript](https://github.com/obadx/quran-transcript)
+* تحويل الرسم العثماني للرسم الصوتي للقرآني الكريم الذي يصف كل قواعد التجويد ما عدا الإشمام: [quran-transcript](https://github.com/obadx/quran-transcript)
+* تدريب النموذج على معمارية [Wav2Vec2BERT](https://huggingface.co/docs/transformers/model_doc/wav2vec2-bert)
+
+
+## استخدام النوذج
+
+
+### استخدام النموذج عن طريق واجهة gradio
+
+قم بتزيل  [uv](https://docs.astral.sh/uv/) 
+
+```bash
+pip install uv
+```
+أو
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+بعد ذلك قم بتنزيل `ffmpeg`
+
+```bash
+sudo apt-get update
+sudo apt-get install -y ffmpeg
+```
+
+أو من خلال `anaconda`
+```bash
+conda install ffmpeg
+```
+
+قم بتشغيل `gradio` ب command واحد فقط:
+```bash
+uvx --no-cache --from https://github.com/obadx/quran-muaalem.git[ui]  quran-muaalem-ui
+```
+او
+```bash
+uvx quran-muaalem[ui]  quran-muaalem-ui
+```
+
+### عن طريق python API
+
+
+#### Installation
+
+First, install the required dependencies:
+
+```bash
+# Install system dependencies
+sudo apt-get install -y ffmpeg libsndfile1 portaudio19-dev
+
+# Install Python packages
+pip install quran-muaalem librosa "numba>=0.61.2"
+```
+
+## Basic Usage Example
+
+```python
+"""
+Basic example of using the Quran Muaalem package for phonetic analysis of Quranic recitation.
+"""
+
+from dataclasses import asdict
+import json
+import logging
+
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+import torch
+from librosa.core import load
+
+# Import the main Muaalem class (adjust import based on your actual package structure)
+from quran_muaalem import Muaalem
+
+# Setup logging to see informative messages
+logging.basicConfig(level=logging.INFO)
+
+def analyze_recitation(audio_path):
+    """
+    Analyze a Quranic recitation audio file using the Muaalem model.
+    
+    Args:
+        audio_path (str): Path to the audio file to analyze
+    """
+    # Configuration
+    sampling_rate = 16000  # Must be 16000 Hz
+    device = "cuda" if torch.cuda.is_available() else "cpu"  # Use GPU if available
+    
+    # Step 1: Prepare the Quranic reference text
+    # Get the Uthmani script for a specific verse (Aya 8, Surah 75 in this example)
+    uthmani_ref = Aya(8, 75).get_by_imlaey_words(17, 9).uthmani
+    
+    # Step 2: Configure the recitation style (Moshaf attributes)
+    moshaf = MoshafAttributes(
+        rewaya="hafs",        # Recitation style (Hafs is most common)
+        madd_monfasel_len=2,  # Length of separated elongation
+        madd_mottasel_len=4,  # Length of connected elongation
+        madd_mottasel_waqf=4, # Length of connected elongation when stopping
+        madd_aared_len=2,     # Length of necessary elongation
+    )
+    # see: https://github.com/obadx/prepare-quran-dataset?tab=readme-ov-file#moshaf-attributes-docs
+    
+    # Step 3: Convert text to phonetic representation
+    # see docs for phnetizer: https://github.com/obadx/quran-transcript
+    phonetizer_out = quran_phonetizer(uthmani_ref, moshaf, remove_spaces=True)
+    
+    # Step 4: Initialize the Muaalem model
+    muaalem = Muaalem(device=device)
+    
+    # Step 5: Load and prepare the audio
+    wave, _ = load(audio_path, sr=sampling_rate, mono=True)
+    
+    # Step 6: Process the audio with the model
+    # The model analyzes the phonetic properties of the recitation
+    outs = muaalem(
+        [wave],           # Audio data
+        [phonetizer_out],          # Phonetic reference
+        sampling_rate=sampling_rate
+    )
+    
+    # Step 7: Display the results
+    for out in outs:
+        print("Predicted Phonemes:", out.phonemes.text)
+        
+        # Display detailed phonetic features for each phoneme
+        for sifa in out.sifat:
+            print(json.dumps(asdict(sifa), indent=2, ensure_ascii=False))
+            print("*" * 30)
+        print("-" * 40)
+
+    # Explaining Results
+    explain_for_terminal(
+        outs[0].phonemes.text,
+        phonetizer_out.phonemes,
+        outs[0].sifat,
+        phonetizer_out.sifat,
+    )
+
+
+if __name__ == "__main__":
+    # Replace with the path to your audio file
+    audio_path = "./assets/test.wav"
+    
+    try:
+        analyze_recitation(audio_path)
+    except Exception as e:
+        logging.error(f"Error processing audio: {e}")
+```
+
+Output:
+
+```bash
+ءِننننَللَااهَبِكُللِشَيءِنعَلِۦۦمُ۾۾۾بَرَااااءَتُممممِنَللَااهِوَرَسُۥۥلِه
+┏━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┓
+┃ Phonemes ┃ Tafashie       ┃ Qalqla       ┃ Ghonna       ┃ Hams Or Jahr ┃ Safeer    ┃ Tikraar     ┃ Tafkheem Or Taqeeq ┃ Istitala      ┃ Shidda Or Rakhawa ┃ Itbaq    ┃
+┡━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━┩
+│ ءِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ننننَ     │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ للَ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اا       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ هَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ بِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ كُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ للِ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ شَ        │ motafashie     │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ي        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ءِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ن        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ عَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ لِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ۦۦ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ مُ        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ۾۾۾      │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ بَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ رَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ mokarar     │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اااا     │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ ءَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ تُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ shadeed           │ monfateh │
+│ ممممِ     │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ نَ        │ not_motafashie │ not_moqalqal │ maghnoon     │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ للَ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ اا       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ mofakham           │ not_mostateel │ rikhw             │ monfateh │
+│ هِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ وَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ رَ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ mokarar     │ mofakham           │ not_mostateel │ between           │ monfateh │
+│ سُ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ safeer    │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ ۥۥ       │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+│ لِ        │ not_motafashie │ not_moqalqal │ not_maghnoon │ jahr         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ between           │ monfateh │
+│ ه        │ not_motafashie │ not_moqalqal │ not_maghnoon │ hams         │ no_safeer │ not_mokarar │ moraqaq            │ not_mostateel │ rikhw             │ monfateh │
+└──────────┴────────────────┴──────────────┴──────────────┴──────────────┴───────────┴─────────────┴────────────────────┴───────────────┴───────────────────┴──────────┘
+```
+
+### API Docs
+
+```python
+class Muaalem:
+    def __init__(
+        self,
+        model_name_or_path: str = "obadx/muaalem-model-v3_2",
+        device: str = "cpu",
+        dtype=torch.bfloat16,
+    ):
+        """
+        Initializing Muallem Model
+
+        Args:
+            model_name_or_path: the huggingface model name or path
+            device: the device to run model on
+            dtype: the torch dtype. Default is `torch.bfloat16` as the model was trained on
+        """
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        waves: list[list[float] | torch.FloatTensor | NDArray],
+        ref_quran_phonetic_script_list: list[QuranPhoneticScriptOutput],
+        sampling_rate: int,
+    ) -> list[MuaalemOutput]:
+        """Infrence Funcion for the Quran Muaalem Project
+
+                waves: input waves  batch , seq_len with different formats described above
+                ref_quran_phonetic_script_list (list[QuranPhoneticScriptOutput]): list of the
+                    phonetized ouput of `quran_transcript.quran_phonetizer` with `remove_space=True`
+
+                sampleing_rate (int): has to be 16000
+
+        Returns:
+            list[MuaalemOutput]:
+                A list of output objects, each containing phoneme predictions and their
+                phonetic features (sifat) for a processed input.
+
+            Each MuaalemOutput contains:
+                phonemes (Unit):
+                    A dataclass representing the predicted phoneme sequence with:
+                        text (str): Concatenated string of all phonemes.
+                        probs (Union[torch.FloatTensor, list[float]]):
+                            Confidence probabilities for each predicted phoneme.
+                        ids (Union[torch.LongTensor, list[int]]):
+                            Token IDs corresponding to each phoneme.
+
+                sifat (list[Sifa]):
+                    A list of phonetic feature dataclasses (one per phoneme) with the
+                    following optional properties (each is a SingleUnit or None):
+                        - phonemes_group (str): the phonemes associated with the `sifa`
+                        - hams_or_jahr (SingleUnit): either `hams` or `jahr`
+                        - shidda_or_rakhawa (SingleUnit): either `shadeed`, `between`, or `rikhw`
+                        - tafkheem_or_taqeeq (SingleUnit): either `mofakham`, `moraqaq`, or `low_mofakham`
+                        - itbaq (SingleUnit): either `monfateh`, or `motbaq`
+                        - safeer (SingleUnit): either `safeer`, or `no_safeer`
+                        - qalqla (SingleUnit): eithr `moqalqal`, or `not_moqalqal`
+                        - tikraar (SingleUnit): either `mokarar` or `not_mokarar`
+                        - tafashie (SingleUnit): either `motafashie`, or `not_motafashie`
+                        - istitala (SingleUnit): either `mostateel`, or `not_mostateel`
+                        - ghonna (SingleUnit): either `maghnoon`, or `not_maghnoon`
+
+            Each SingleUnit in Sifa properties contains:
+                text (str): The feature's categorical label (e.g., "hams", "shidda").
+                prob (float): Confidence probability for this feature.
+                idx (int): Identifier for the feature class.
+        """
+```

SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+src/quran_muaalem/__init__.py
+src/quran_muaalem/decode.py
+src/quran_muaalem/explain.py
+src/quran_muaalem/explain_gradio.py
+src/quran_muaalem/gradio_app.py
+src/quran_muaalem/inference.py
+src/quran_muaalem/muaalem_typing.py
+src/quran_muaalem.egg-info/PKG-INFO
+src/quran_muaalem.egg-info/SOURCES.txt
+src/quran_muaalem.egg-info/dependency_links.txt
+src/quran_muaalem.egg-info/entry_points.txt
+src/quran_muaalem.egg-info/requires.txt
+src/quran_muaalem.egg-info/top_level.txt
+src/quran_muaalem/modeling/__init__.py
+src/quran_muaalem/modeling/configuration_multi_level_ctc.py
+src/quran_muaalem/modeling/modeling_multi_level_ctc.py
+src/quran_muaalem/modeling/multi_level_tokenizer.py
+src/quran_muaalem/modeling/vocab.py
+tests/test_align_phonemes.py
+tests/test_best_match.py
+tests/test_exaplain_modules.py
+tests/test_modules.py
+tests/test_muaalem_infrence.py

architecture.md

@@ -0,0 +1,63 @@
+# المعمارية
+
+يعتمد المشروع معمارية **CTC متعددة المستويات** فوق Wav2Vec2BERT، بحيث يتنبأ كل مستوى بسلسلة مختلفة:
+
+- **سلسلة الفونيمات** (المستوى الأساسي)
+- **صفات الحروف** (مستويات ثانوية: رأس لكل صفة)
+
+المكوّنات الأساسية موجودة في `src/quran_muaalem/modeling/`.
+
+## التدفق العام
+
+```
+الصوت (16 kHz)
+  → مستخرج الخصائص (AutoFeatureExtractor)
+  → مشفر Wav2Vec2BERT
+  → رؤوس CTC متعددة المستويات
+  → فك ترميز CTC + محاذاة
+  → فونيمات + صفات
+```
+
+## رؤوس CTC متعددة المستويات
+
+`Wav2Vec2BertForMultilevelCTC` في `modeling_multi_level_ctc.py` ينشئ رأسًا لكل مستوى:
+
+- `phonemes`
+- `hams_or_jahr`
+- `shidda_or_rakhawa`
+- `tafkheem_or_taqeeq`
+- `itbaq`
+- `safeer`
+- `qalqla`
+- `tikraar`
+- `tafashie`
+- `istitala`
+- `ghonna`
+
+كل رأس له خسارة CTC مستقلة. أوزان الخسائر تُضبط عبر:
+
+- `level_to_vocab_size`
+- `level_to_loss_weight`
+
+(راجع `configuration_multi_level_ctc.py`).
+
+## الترميز لكل مستوى
+
+`MultiLevelTokenizer` يبني مُرمّزًا لكل مستوى باستخدام `Wav2Vec2CTCTokenizer` وقواميس النموذج. رموز الفونيمات هي الرموز الصوتية العربية، بينما رموز الصفات هي وسوم عربية محاطة بأقواس تُشتق من `SifaOutput`.
+
+## فك الترميز والمحاذاة
+
+أثناء الاستدلال:
+
+1. ينتج النموذج لوغيتس لكل مستوى.
+2. يتم فك ترميز كل مستوى بـ CTC الجشعة (top‑1 مع دمج التكرارات وحذف الفراغ).
+3. تُقسّم سلسلة الفونيمات إلى مجموعات فونيمية.
+4. تُحاذى سلاسل الصفات مع المجموعات ومع المرجع إن توفر.
+
+منطق المحاذاة موجود في `src/quran_muaalem/decode.py`.
+
+## ملاحظات للباحثين
+
+- **المستوى الأساسي:** الفونيمات هي أكثر الإشارات استقرارًا.
+- **الصفات** تعتمد على جودة المحاذاة؛ من الأفضل قياس الدقة مع/بدون محاذاة.
+- **أوزان الخسائر** تؤثر مباشرة على دقة الصفات ويُنصح بضبطها تجريبيًا.

byteorder

@@ -0,0 +1 @@
+little

configuration_multi_level_ctc.py

@@ -0,0 +1,320 @@
+from transformers import PretrainedConfig
+
+
+class Wav2Vec2BertForMultilevelCTCConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`Wav2Vec2BertModel`]. It is used to
+    instantiate an Wav2Vec2Bert model according to the specified arguments, defining the model architecture.
+    Instantiating a configuration with the defaults will yield a similar configuration to that of the Wav2Vec2Bert
+    [facebook/wav2vec2-bert-rel-pos-large](https://huggingface.co/facebook/wav2vec2-bert-rel-pos-large)
+    architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        level_to_vocab_size (`dict[str, int]`, *optional*):
+            Every level has its own vocabulary: {'phonemes': 44, 'hams_or_jahr': 3, ....}
+            Vocabulary size of the Wav2Vec2Bert model. Defines the number of different tokens that can be
+            represented by the `inputs_ids` passed when calling [`Wav2Vec2BertModel`]. Vocabulary size of the
+            model. Defines the different tokens that can be represented by the *inputs_ids* passed to the forward
+            method of [`Wav2Vec2BertModel`].
+        level_to_loss_weigth (`dict[str, int]`, *optional*):
+            Every level has its own loss weigth such that the sum of all levels adds to 1:
+            If you supply only one level: the rest of the level will have loss weigth of (1-given_loss_weigth) / nmber of rest of levels
+
+        hidden_size (`int`, *optional*, defaults to 1024):
+            Dimensionality of the encoder layers and the pooler layer.
+        num_hidden_layers (`int`, *optional*, defaults to 24):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 16):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        intermediate_size (`int`, *optional*, defaults to 4096):
+            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
+        feature_projection_input_dim (`int`, *optional*, defaults to 160):
+            Input dimension of this model, i.e the dimension after processing input audios with [`SeamlessM4TFeatureExtractor`] or [`Wav2Vec2BertProcessor`].
+        hidden_act (`str` or `function`, *optional*, defaults to `"swish"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"`, `"swish"` and `"gelu_new"` are supported.
+        hidden_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        activation_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for activations inside the fully connected layer.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        feat_proj_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout probability for the feature projection.
+        final_dropout (`float`, *optional*, defaults to 0.1):
+            The dropout probability for the final projection layer of [`Wav2Vec2BertForCTC`].
+        layerdrop (`float`, *optional*, defaults to 0.1):
+            The LayerDrop probability. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more
+            details.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-05):
+            The epsilon used by the layer normalization layers.
+        apply_spec_augment (`bool`, *optional*, defaults to `True`):
+            Whether to apply *SpecAugment* data augmentation to the outputs of the feature encoder. For reference see
+            [SpecAugment: A Simple Data Augmentation Method for Automatic Speech
+            Recognition](https://huggingface.co/papers/1904.08779).
+        mask_time_prob (`float`, *optional*, defaults to 0.05):
+            Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking
+            procedure generates `mask_time_prob*len(time_axis)/mask_time_length ``independent masks over the axis. If
+            reasoning from the probability of each feature vector to be chosen as the start of the vector span to be
+            masked, *mask_time_prob* should be `prob_vector_start*mask_time_length`. Note that overlap may decrease the
+            actual percentage of masked vectors. This is only relevant if `apply_spec_augment is True`.
+        mask_time_length (`int`, *optional*, defaults to 10):
+            Length of vector span along the time axis.
+        mask_time_min_masks (`int`, *optional*, defaults to 2):
+            The minimum number of masks of length `mask_feature_length` generated along the time axis, each time step,
+            irrespectively of `mask_feature_prob`. Only relevant if `mask_time_prob*len(time_axis)/mask_time_length <
+            mask_time_min_masks`.
+        mask_feature_prob (`float`, *optional*, defaults to 0.0):
+            Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The
+            masking procedure generates `mask_feature_prob*len(feature_axis)/mask_time_length` independent masks over
+            the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector
+            span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap
+            may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment is
+            True`.
+        mask_feature_length (`int`, *optional*, defaults to 10):
+            Length of vector span along the feature axis.
+        mask_feature_min_masks (`int`, *optional*, defaults to 0):
+            The minimum number of masks of length `mask_feature_length` generated along the feature axis, each time
+            step, irrespectively of `mask_feature_prob`. Only relevant if
+            `mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks`.
+        ctc_loss_reduction (`str`, *optional*, defaults to `"sum"`):
+            Specifies the reduction to apply to the output of `torch.nn.CTCLoss`. Only relevant when training an
+            instance of [`Wav2Vec2BertForCTC`].
+        ctc_zero_infinity (`bool`, *optional*, defaults to `False`):
+            Whether to zero infinite losses and the associated gradients of `torch.nn.CTCLoss`. Infinite losses mainly
+            occur when the inputs are too short to be aligned to the targets. Only relevant when training an instance
+            of [`Wav2Vec2BertForCTC`].
+        use_weighted_layer_sum (`bool`, *optional*, defaults to `False`):
+            Whether to use a weighted average of layer outputs with learned weights. Only relevant when using an
+            instance of [`Wav2Vec2BertForSequenceClassification`].
+        classifier_proj_size (`int`, *optional*, defaults to 768):
+            Dimensionality of the projection before token mean-pooling for classification.
+        tdnn_dim (`tuple[int]` or `list[int]`, *optional*, defaults to `(512, 512, 512, 512, 1500)`):
+            A tuple of integers defining the number of output channels of each 1D convolutional layer in the *TDNN*
+            module of the *XVector* model. The length of *tdnn_dim* defines the number of *TDNN* layers.
+        tdnn_kernel (`tuple[int]` or `list[int]`, *optional*, defaults to `(5, 3, 3, 1, 1)`):
+            A tuple of integers defining the kernel size of each 1D convolutional layer in the *TDNN* module of the
+            *XVector* model. The length of *tdnn_kernel* has to match the length of *tdnn_dim*.
+        tdnn_dilation (`tuple[int]` or `list[int]`, *optional*, defaults to `(1, 2, 3, 1, 1)`):
+            A tuple of integers defining the dilation factor of each 1D convolutional layer in *TDNN* module of the
+            *XVector* model. The length of *tdnn_dilation* has to match the length of *tdnn_dim*.
+        xvector_output_dim (`int`, *optional*, defaults to 512):
+            Dimensionality of the *XVector* embedding vectors.
+        pad_token_id (`int`, *optional*, defaults to 0): The id of the _beginning-of-stream_ token.
+        bos_token_id (`int`, *optional*, defaults to 1): The id of the _padding_ token.
+        eos_token_id (`int`, *optional*, defaults to 2): The id of the _end-of-stream_ token.
+        add_adapter (`bool`, *optional*, defaults to `False`):
+            Whether a convolutional attention network should be stacked on top of the Wav2Vec2Bert Encoder. Can be very
+            useful for warm-starting Wav2Vec2Bert for SpeechEncoderDecoder models.
+        adapter_kernel_size (`int`, *optional*, defaults to 3):
+            Kernel size of the convolutional layers in the adapter network. Only relevant if `add_adapter is True`.
+        adapter_stride (`int`, *optional*, defaults to 2):
+            Stride of the convolutional layers in the adapter network. Only relevant if `add_adapter is True`.
+        num_adapter_layers (`int`, *optional*, defaults to 1):
+            Number of convolutional layers that should be used in the adapter network. Only relevant if `add_adapter is
+            True`.
+        adapter_act (`str` or `function`, *optional*, defaults to `"relu"`):
+            The non-linear activation function (function or string) in the adapter layers. If string, `"gelu"`,
+            `"relu"`, `"selu"`, `"swish"` and `"gelu_new"` are supported.
+        use_intermediate_ffn_before_adapter (`bool`, *optional*, defaults to `False`):
+            Whether an intermediate feed-forward block should be stacked on top of the Wav2Vec2Bert Encoder and before the adapter network.
+             Only relevant if `add_adapter is True`.
+        output_hidden_size (`int`, *optional*):
+            Dimensionality of the encoder output layer. If not defined, this defaults to *hidden-size*. Only relevant
+            if `add_adapter is True`.
+        position_embeddings_type (`str`, *optional*, defaults to `"relative_key"`):
+            Can be specified to :
+                - `rotary`, for rotary position embeddings.
+                - `relative`, for relative position embeddings.
+                - `relative_key`, for relative position embeddings as defined by Shaw in [Self-Attention
+            with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155).
+            If left to `None`, no relative position embeddings is applied.
+        rotary_embedding_base (`int`, *optional*, defaults to 10000):
+            If `"rotary"` position embeddings are used, defines the size of the embedding base.
+        max_source_positions (`int`, *optional*, defaults to 5000):
+            if `"relative"` position embeddings are used, defines the maximum source input positions.
+        left_max_position_embeddings (`int`, *optional*, defaults to 64):
+            If `"relative_key"` (aka Shaw) position embeddings are used, defines the left clipping value for relative positions.
+        right_max_position_embeddings (`int`, *optional*, defaults to 8):
+            If `"relative_key"` (aka Shaw) position embeddings are used, defines the right clipping value for relative positions.
+        conv_depthwise_kernel_size (`int`, *optional*, defaults to 31):
+            Kernel size of convolutional depthwise 1D layer in Conformer blocks.
+        conformer_conv_dropout (`float`, *optional*, defaults to 0.1):
+            The dropout probability for all convolutional layers in Conformer blocks.
+    Example:
+
+    ```python
+    >>> from transformers import Wav2Vec2BertConfig, Wav2Vec2BertModel
+
+    >>> # Initializing a Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large style configuration
+    >>> configuration = Wav2Vec2BertConfig()
+
+    >>> # Initializing a model (with random weights) from the facebook/wav2vec2-bert-rel-pos-large style configuration
+    >>> model = Wav2Vec2BertModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "multi_level_ctc"
+
+    def __init__(
+        self,
+        level_to_vocab_size: dict[str, int] = {},
+        level_to_loss_weight: dict[str, float] = {"phonemes": 0.4},
+        hidden_size=1024,
+        num_hidden_layers=24,
+        num_attention_heads=16,
+        intermediate_size=4096,
+        feature_projection_input_dim=160,
+        hidden_act="swish",
+        hidden_dropout=0.0,
+        activation_dropout=0.0,
+        attention_dropout=0.0,
+        feat_proj_dropout=0.0,
+        final_dropout=0.1,
+        layerdrop=0.1,
+        initializer_range=0.02,
+        layer_norm_eps=1e-5,
+        apply_spec_augment=True,
+        mask_time_prob=0.05,
+        mask_time_length=10,
+        mask_time_min_masks=2,
+        mask_feature_prob=0.0,
+        mask_feature_length=10,
+        mask_feature_min_masks=0,
+        ctc_loss_reduction="sum",
+        ctc_zero_infinity=False,
+        use_weighted_layer_sum=False,
+        classifier_proj_size=768,
+        tdnn_dim=(512, 512, 512, 512, 1500),
+        tdnn_kernel=(5, 3, 3, 1, 1),
+        tdnn_dilation=(1, 2, 3, 1, 1),
+        xvector_output_dim=512,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        add_adapter=False,
+        adapter_kernel_size=3,
+        adapter_stride=2,
+        num_adapter_layers=1,
+        adapter_act="relu",
+        use_intermediate_ffn_before_adapter=False,
+        output_hidden_size=None,
+        position_embeddings_type="relative_key",
+        rotary_embedding_base=10000,
+        max_source_positions=5000,
+        left_max_position_embeddings=64,
+        right_max_position_embeddings=8,
+        conv_depthwise_kernel_size=31,
+        conformer_conv_dropout=0.1,
+        **kwargs,
+    ):
+        super().__init__(
+            **kwargs,
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+        )
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.intermediate_size = intermediate_size
+        self.hidden_act = hidden_act
+        self.num_attention_heads = num_attention_heads
+        self.feature_projection_input_dim = feature_projection_input_dim
+        self.hidden_dropout = hidden_dropout
+        self.attention_dropout = attention_dropout
+        self.activation_dropout = activation_dropout
+        self.feat_proj_dropout = feat_proj_dropout
+        self.final_dropout = final_dropout
+        self.layerdrop = layerdrop
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+        self.level_to_vocab_size = level_to_vocab_size
+        self.use_weighted_layer_sum = use_weighted_layer_sum
+        self.max_source_positions = max_source_positions
+
+        loss_weights_sum = sum(level_to_loss_weight.values())
+        if loss_weights_sum > 1:
+            raise ValueError(
+                f"The sum of loss weight per level has to be less than one! got: `{level_to_loss_weight}`"
+            )
+        unmentioned_loss_levels_count = len(
+            [l for l in self.level_to_vocab_size if l not in level_to_loss_weight]
+        )
+        for level in self.level_to_vocab_size:
+            if level not in level_to_loss_weight:
+                level_to_loss_weight[level] = (
+                    1 - loss_weights_sum
+                ) / unmentioned_loss_levels_count
+        self.level_to_loss_weight = level_to_loss_weight
+
+        if position_embeddings_type is not None and position_embeddings_type not in [
+            "rotary",
+            "relative",
+            "relative_key",
+        ]:
+            raise ValueError(
+                """
+                `position_embeddings_type` is not valid. It must be one of the following values:
+                `["rotary", "relative", "relative_key"]` or left as `None`.
+                """
+            )
+        self.position_embeddings_type = position_embeddings_type
+        self.rotary_embedding_base = rotary_embedding_base
+        self.left_max_position_embeddings = left_max_position_embeddings
+        self.right_max_position_embeddings = right_max_position_embeddings
+
+        # Conformer-block related
+        self.conv_depthwise_kernel_size = conv_depthwise_kernel_size
+        self.conformer_conv_dropout = conformer_conv_dropout
+
+        # fine-tuning config parameters for SpecAugment: https://huggingface.co/papers/1904.08779
+        self.apply_spec_augment = apply_spec_augment
+        self.mask_time_prob = mask_time_prob
+        self.mask_time_length = mask_time_length
+        self.mask_time_min_masks = mask_time_min_masks
+        self.mask_feature_prob = mask_feature_prob
+        self.mask_feature_length = mask_feature_length
+        self.mask_feature_min_masks = mask_feature_min_masks
+
+        # ctc loss
+        self.ctc_loss_reduction = ctc_loss_reduction
+        self.ctc_zero_infinity = ctc_zero_infinity
+
+        # adapter
+        self.add_adapter = add_adapter
+        self.adapter_kernel_size = adapter_kernel_size
+        self.adapter_stride = adapter_stride
+        self.num_adapter_layers = num_adapter_layers
+        self.adapter_act = adapter_act
+        self.output_hidden_size = (
+            output_hidden_size if output_hidden_size is not None else hidden_size
+        )
+        if use_intermediate_ffn_before_adapter and not add_adapter:
+            raise ValueError(
+                "`use_intermediate_ffn_before_adapter` is `True` but `add_adapter` is `False`."
+            )
+        self.use_intermediate_ffn_before_adapter = use_intermediate_ffn_before_adapter
+
+        # SequenceClassification-specific parameter. Feel free to ignore for other classes.
+        self.classifier_proj_size = classifier_proj_size
+
+        # XVector-specific parameters. Feel free to ignore for other classes.
+        self.tdnn_dim = list(tdnn_dim)
+        self.tdnn_kernel = list(tdnn_kernel)
+        self.tdnn_dilation = list(tdnn_dilation)
+        self.xvector_output_dim = xvector_output_dim
+
+    @property
+    def inputs_to_logits_ratio(self):
+        ratio = self.feature_projection_input_dim * 2
+        if self.add_adapter:
+            ratio = ratio * (self.adapter_stride**self.num_adapter_layers)
+        return ratio

conftest.py

@@ -0,0 +1,22 @@
+import pytest
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--skip-slow",
+        action="store_true",
+        default=False,
+        help="Skip tests marked as slow",
+    )
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "slow: mark test as slow to run")
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--skip-slow"):
+        skip_slow = pytest.mark.skip(reason="Skipped due to --skip-slow flag")
+        for item in items:
+            if "slow" in item.keywords:
+                item.add_marker(skip_slow)

contributing.md

@@ -0,0 +1,7 @@
+# المساهمة
+
+- افتح قضايا أو طلبات دمج عبر https://github.com/obadx/quran-muaalem.
+- حاول أن تكون التغييرات مركزة إما في `src/quran_muaalem/` أو `quran-transcript/` قدر الإمكان.
+- أضف أو حدّث الاختبارات في المجموعة المناسبة (`tests/` أو `quran-transcript/tests/`).
+
+إذا احتجت دليل أسلوب أو إعدادات تنسيق، أخبرني لأضيفها.

data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:908eb046e8ce28359c047aa9701517ceab69ce2f14cd5aa2bb551b518534042c
+size 14476

decode.py

@@ -0,0 +1,580 @@
+import logging
+from typing import Sequence, Any
+from dataclasses import dataclass
+import torch
+import numpy as np
+from numpy.typing import NDArray
+
+from .modeling.vocab import PAD_TOKEN_IDX
+from .muaalem_typing import Unit
+
+
+# def align_predicted_sequence(
+#     ref: Sequence[Any], predicted: Sequence[Any]
+# ) -> Sequence[Any]:
+#     """Aligns the preficeted sequence to the ref sequnce
+#
+#     Example (1): `predicted` length > `ref` length
+#         ref: abcde
+#         predicted: abcdef
+#         Returns: abcde
+#
+#     Example (2): `predicted` length <`ref` length
+#         ref: abcde
+#         predicted: abcd
+#         Returns: abcde
+#
+#     Returns:
+#         Sequnce[Any]: new precicted sequence that best matches the ref sequence
+#     """
+#     n = len(ref)
+#     m = len(predicted)
+#     if n == m:
+#         return predicted
+#     if n == 0:
+#         return []
+#     if m == 0:
+#         return ref
+#
+#     dp = [[0] * (m + 1) for _ in range(n + 1)]
+#
+#     for i in range(1, n + 1):
+#         dp[i][0] = 0
+#     for j in range(1, m + 1):
+#         dp[0][j] = 0
+#
+#     for i in range(1, n + 1):
+#         for j in range(1, m + 1):
+#             insertion = dp[i - 1][j]
+#             deletion = dp[i][j - 1]
+#             match_cost = dp[i - 1][j - 1] + (1 if ref[i - 1] != predicted[j - 1] else 0)
+#             dp[i][j] = min(insertion, deletion, match_cost)
+#
+#     i, j = n, m
+#     output_chars = []
+#     while i > 0 or j > 0:
+#         if (
+#             i > 0
+#             and j > 0
+#             and ref[i - 1] == predicted[j - 1]
+#             and dp[i][j] == dp[i - 1][j - 1]
+#         ):
+#             output_chars.append(predicted[j - 1])
+#             i -= 1
+#             j -= 1
+#         elif i > 0 and dp[i][j] == dp[i - 1][j]:
+#             output_chars.append(ref[i - 1])
+#             i -= 1
+#         elif j > 0 and dp[i][j] == dp[i][j - 1]:
+#             j -= 1
+#         else:
+#             output_chars.append(predicted[j - 1])
+#             i -= 1
+#             j -= 1
+#
+#     # return "".join(output_chars[::-1])
+#     return output_chars[::-1]
+
+
+# def align_predicted_sequence(ref, predicted):
+#     n = len(ref)
+#     m = len(predicted)
+#     if m == n:
+#         return predicted
+#
+#     INF = 10**9
+#     dp = [[0] * (m + 1) for _ in range(n + 1)]
+#     choice = [[0] * (m + 1) for _ in range(n + 1)]
+#
+#     for j in range(m + 1):
+#         dp[0][j] = 0
+#
+#     for i in range(1, n + 1):
+#         dp[i][0] = INF
+#
+#     for i in range(1, n + 1):
+#         for j in range(1, m + 1):
+#             # above
+#             option1 = dp[i][j - 1]
+#             # adjacent
+#             if j >= i:
+#                 cost = 0 if predicted[j - 1] == ref[i - 1] else 1
+#                 option2 = dp[i - 1][j - 1] + cost
+#             else:
+#                 option2 = INF
+#
+#             if option2 <= option1:
+#                 dp[i][j] = option2
+#                 choice[i][j] = 1
+#             else:
+#                 dp[i][j] = option1
+#                 choice[i][j] = 0
+#
+#     print(np.array(dp))
+#     print(np.array(choice))
+#
+#     res_chars = []
+#     i, j = n, m
+#     while i > 0 and j > 0:
+#         if choice[i][j] == 1:
+#             res_chars.append(predicted[j - 1])
+#             i -= 1
+#             j -= 1
+#         else:
+#             j -= 1
+#
+#     return res_chars[::-1]
+
+
+def align_chunked_phonemes_sequence(
+    ref: list[list[str]],
+    predicted: list[list[str]],
+) -> list[bool]:
+    """Aligns phonemes level to get mask that descripts what is missing
+
+    Returns the mask for the `ref` inputs that best matches the `predicted`
+    Note element wise comparison but retuns mask for best seqence (even with errors)
+
+    Example (1): `predicted` length > `ref` length
+        ref: abcde
+        predicted: abcdef
+        Returns: [T, T, T, T]
+
+    Example (2): `predicted` length <`ref` length
+        ref: abcde
+        predicted: abcd
+        Returns: [T, T, T, T, F]
+
+    Example (2): `predicted` length <`ref` length
+        ref: afcde
+        predicted: abcd
+        Returns: [T, T, T, T, F]
+
+
+    Len(mask] == Len(ref)
+
+    """
+
+    n = len(predicted)
+    m = len(ref)
+
+    if len(predicted) == len(ref):
+        return [True] * len(predicted)
+
+    if m == 0:
+        raise ValueError("`ref` length must not be zero length")
+
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    choice = [[0] * (m + 1) for _ in range(n + 1)]
+
+    for j in range(m + 1):
+        dp[0][j] = 0
+
+    for i in range(1, n + 1):
+        dp[i][0] = i
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            option1 = dp[i][j - 1]
+            option2 = dp[i - 1][j] + 1
+            cost = 0 if predicted[i - 1][0] == ref[j - 1][0] else 1
+            option3 = dp[i - 1][j - 1] + cost
+
+            if option3 <= option1 and option3 <= option2:
+                dp[i][j] = option3
+                choice[i][j] = 3
+            elif option1 <= option2:
+                dp[i][j] = option1
+                choice[i][j] = 1
+            else:
+                dp[i][j] = option2
+                choice[i][j] = 2
+
+    i = n
+    j = m
+    mask = []
+    # res_chars = []
+    while i > 0 or j > 0:
+        if i > 0 and j > 0:
+            if choice[i][j] == 3:
+                # res_chars.append(ref[j - 1])
+                mask.append(True)
+                i -= 1
+                j -= 1
+            elif choice[i][j] == 2:
+                # res_chars.append(missing_placeholder)
+                i -= 1
+            else:
+                j -= 1
+                mask.append(False)
+        elif i > 0:
+            # res_chars.append(missing_placeholder)
+            i -= 1
+        else:
+            j -= 1
+            mask.append(False)
+
+    return mask[::-1]
+
+
+def align_predicted_sequence(
+    ref: Sequence[Any] | torch.LongTensor,
+    predicted: Sequence[Any] | torch.LongTensor,
+    missing_placeholder=-100,
+) -> Sequence[Any] | torch.LongTensor:
+    """Aligns the preficeted sequence to the ref sequnce
+
+    Example (1): `predicted` length > `ref` length
+        ref: abcde
+        predicted: abcdef
+        Returns: abcde
+
+    Example (2): `predicted` length <`ref` length
+        ref: abcde
+        predicted: abcd
+        Returns: abcd(missing_placeholder)
+
+    Returns:
+        Sequnce[Any]: new precicted sequence that best matches the ref sequence
+    """
+
+    n = len(ref)
+    m = len(predicted)
+
+    if len(ref) == len(predicted):
+        return predicted, [True] * len(ref)
+
+    if m == 0:
+        return [missing_placeholder] * n
+
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    choice = [[0] * (m + 1) for _ in range(n + 1)]
+
+    for j in range(m + 1):
+        dp[0][j] = 0
+
+    for i in range(1, n + 1):
+        dp[i][0] = i
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            option1 = dp[i][j - 1]
+            option2 = dp[i - 1][j] + 1
+            cost = 0 if ref[i - 1] == predicted[j - 1] else 1
+            option3 = dp[i - 1][j - 1] + cost
+
+            if option3 <= option1 and option3 <= option2:
+                dp[i][j] = option3
+                choice[i][j] = 3
+            elif option1 <= option2:
+                dp[i][j] = option1
+                choice[i][j] = 1
+            else:
+                dp[i][j] = option2
+                choice[i][j] = 2
+
+    i = n
+    j = m
+    mask = []
+    res_chars = []
+    while i > 0 or j > 0:
+        if i > 0 and j > 0:
+            if choice[i][j] == 3:
+                res_chars.append(predicted[j - 1])
+                mask.append(True)
+                i -= 1
+                j -= 1
+            elif choice[i][j] == 2:
+                res_chars.append(missing_placeholder)
+                i -= 1
+            else:
+                j -= 1
+                mask.append(False)
+        elif i > 0:
+            res_chars.append(missing_placeholder)
+            i -= 1
+        else:
+            j -= 1
+            mask.append(False)
+
+    return res_chars[::-1], mask[::-1]
+
+
+@dataclass
+class CTCDecodeOut:
+    """
+    Both are 1D Tensors
+    """
+
+    ids: torch.LongTensor
+    p: torch.FloatTensor
+
+
+def ctc_decode(
+    batch_ids: torch.LongTensor,
+    batch_probs: torch.FloatTensor,
+    blank_id=PAD_TOKEN_IDX,
+    collapse_consecutive=True,
+) -> list[CTCDecodeOut]:
+    """
+    batch_ids (torch.LongTensor): batch on integer ids of shape: batch, sequecne_len
+    batch_probs (torch.LongTensor): batch on float32 ids of shape: batch, sequecne_len
+
+    Return:
+        list[tuple[list[int], float]]]:
+
+
+    """
+    outs = []
+    assert batch_ids.shape == batch_probs.shape
+    for seq_idx, seq in enumerate(batch_ids):
+        if collapse_consecutive:
+            tokens = []
+            probs = []
+            start = 0
+            end = 0
+            if len(seq) == 1 and seq[0] != blank_id:
+                tokens.append(seq[0])
+                probs.append(batch_probs[seq_idx][0])
+
+            for idx in range(len(seq) - 1):
+                curr = seq[idx]
+                next = seq[idx + 1]
+                # Last Item
+                if idx == len(seq) - 2 and curr != blank_id:
+                    if curr == next:
+                        end = idx + 2
+                        tokens.append(curr)
+                        probs.append(
+                            batch_probs[seq_idx][start:end].sum() / (end - start)
+                        )
+                    elif curr != next:
+                        end = idx + 1
+                        tokens.append(curr)
+                        probs.append(
+                            batch_probs[seq_idx][start:end].sum() / (end - start)
+                        )
+                        tokens.append(next)
+                        probs.append(batch_probs[seq_idx][idx + 1])
+                # Normal Case
+                elif curr != next and curr != blank_id:
+                    end = idx + 1
+                    tokens.append(curr)
+                    probs.append(batch_probs[seq_idx][start:end].sum() / (end - start))
+                    start = end
+                elif curr == blank_id:
+                    start = idx + 1
+
+            outs.append(
+                CTCDecodeOut(
+                    ids=torch.LongTensor(tokens),
+                    p=torch.FloatTensor(probs),
+                )
+            )
+        else:
+            mask = seq != blank_id
+            tokens = seq[mask]
+            probs = batch_probs[seq_idx][mask]
+            outs.append(CTCDecodeOut(ids=tokens, p=probs))
+    return outs
+
+
+# def multilevel_greedy_decode(
+#     level_to_probs: dict[str, torch.FloatTensor],
+#     level_to_id_to_vocab: dict[str, dict[int, str]],
+#     level_to_ref_ids: dict[str, torch.LongTensor],
+#     missing_placeholder=-100,
+#     pad_idx=PAD_TOKEN_IDX,
+# ) -> dict[str, list[Unit]]:
+#     level_to_units = {}
+#     for level in level_to_probs:
+#         batch_probs, batch_ids = level_to_probs[level].topk(1, dim=-1)
+#         decode_outs = ctc_decode(
+#             batch_ids.squeeze(-1), batch_probs.squeeze(-1), collapse_consecutive=True
+#         )
+#         level_to_units[level] = []
+#         for seq_idx, decode_out in enumerate(decode_outs):
+#             # Trying to align Ids of the sifat levels
+#             if level != "phonemes":
+#                 aligned_ids, mask = align_predicted_sequence(
+#                     level_to_ref_ids[level][seq_idx],
+#                     decode_out.ids,
+#                     missing_placeholder=missing_placeholder,
+#                 )
+#             else:
+#                 aligned_ids = decode_out.ids
+#
+#             probs = decode_out.p
+#             if len(aligned_ids) != len(decode_out.ids):
+#                 aligned_ids = torch.LongTensor(aligned_ids)
+#                 mask = torch.BoolTensor(mask)
+#
+#                 new_probs = torch.zeros(len(aligned_ids), dtype=torch.float32)
+#                 new_probs[aligned_ids != missing_placeholder] = probs[mask]
+#
+#                 aligned_ids[aligned_ids == missing_placeholder] = pad_idx
+#                 probs = new_probs
+#
+#             probs = decode_out.p.clone()
+#             text = ""
+#             for idx in aligned_ids:
+#                 text += level_to_id_to_vocab[level][int(idx)]
+#             level_to_units[level].append(
+#                 Unit(
+#                     text=text,
+#                     probs=probs,
+#                     ids=aligned_ids,
+#                 ),
+#             )
+#
+#     return level_to_units
+
+
+def phonemes_level_greedy_decode(
+    probs: torch.FloatTensor,
+    phonemes_level_vocab: dict[int, str],
+) -> list[Unit]:
+    """Decodes only phonemes level
+
+    Args:
+        probs (torch.FloatTensor) of shape batch, seq_len, num_classes
+        phonmes_level_vocab (dict[int, str]): mapping ids of phonemes to the
+            acutial string represnetation
+    """
+    batch_probs, batch_ids = probs.topk(1, dim=-1)
+    decode_outs = ctc_decode(
+        batch_ids.squeeze(-1), batch_probs.squeeze(-1), collapse_consecutive=True
+    )
+    units = []
+    for seq_idx, decode_out in enumerate(decode_outs):
+        text = ""
+        for idx in decode_out.ids:
+            text += phonemes_level_vocab[int(idx)]
+        units.append(
+            Unit(
+                text=text,
+                probs=decode_out.p,
+                ids=decode_out.ids,
+            ),
+        )
+    return units
+
+
+def multilevel_greedy_decode(
+    level_to_probs: dict[str, torch.FloatTensor],
+    level_to_id_to_vocab: dict[str, dict[int, str]],
+    level_to_ref_ids: dict[str, torch.LongTensor],
+    chunked_phonemes_batch: list[list[str]],
+    ref_chuncked_phonemes_batch: list[list[str]],
+    phonemes_units: list[Unit],
+    missing_placeholder=-100,
+    pad_idx=PAD_TOKEN_IDX,
+) -> dict[str, list[Unit]]:
+    level_to_units = {}
+    for level in level_to_probs:
+        if level == "phonemes":
+            continue
+        batch_probs, batch_ids = level_to_probs[level].topk(1, dim=-1)
+        decode_outs = ctc_decode(
+            batch_ids.squeeze(-1), batch_probs.squeeze(-1), collapse_consecutive=True
+        )
+        level_to_units[level] = []
+        for seq_idx, decode_out in enumerate(decode_outs):
+            # Trying to align Ids of the sifat levels
+            phonemes_mask = align_chunked_phonemes_sequence(
+                ref=ref_chuncked_phonemes_batch[seq_idx],
+                predicted=chunked_phonemes_batch[seq_idx],
+            )
+            phonemes_mask = torch.BoolTensor(phonemes_mask)
+
+            # NOTE:
+            # We want to align every level with predited phonme, but
+            # in some cases the length of every sifa level is > or < the
+            # length for the predited phonemes
+            # we slove this by two steps
+            # 1. Align the sifa level with length mismatch to the refrence sifa level
+            # 2. align the alinged sifa level back to the the length of prediced phonmes
+            if len(decode_out.ids) != len(chunked_phonemes_batch[seq_idx]) and (
+                len(chunked_phonemes_batch[seq_idx])
+                <= len(ref_chuncked_phonemes_batch[seq_idx])
+            ):
+                logging.info(f"Sequence: `{seq_idx}` has mismatch Level: {level}")
+                # 1. Align sifa level to the reference sifa level
+                ref_aligned_ids, mask = align_predicted_sequence(
+                    level_to_ref_ids[level][seq_idx],
+                    decode_out.ids,
+                    missing_placeholder=missing_placeholder,
+                )
+
+                probs = decode_out.p
+                ref_aligned_ids = torch.LongTensor(ref_aligned_ids)
+                mask = torch.BoolTensor(mask)
+
+                new_probs = torch.zeros(len(ref_aligned_ids), dtype=torch.float32)
+                new_probs[ref_aligned_ids != missing_placeholder] = probs[mask]
+
+                ref_aligned_ids[ref_aligned_ids == missing_placeholder] = pad_idx
+
+                # 2. Align the predicted aligned to the ref back to the predicted seqence
+                aligned_ids = ref_aligned_ids[phonemes_mask]
+                new_probs = ref_aligned_ids[phonemes_mask]
+
+                probs = new_probs
+            else:
+                aligned_ids = decode_out.ids
+                probs = decode_out.p
+
+            text = ""
+            for idx in aligned_ids:
+                text += level_to_id_to_vocab[level][int(idx)]
+            level_to_units[level].append(
+                Unit(
+                    text=text,
+                    probs=probs,
+                    ids=aligned_ids,
+                ),
+            )
+    level_to_units["phonemes"] = phonemes_units
+
+    return level_to_units
+
+
+def align_sequence(
+    seq: Sequence[int] | torch.LongTensor, target_len: int, min_repeat: int = 3
+) -> list[int]:
+    """Aligns a sequence by removing items from the longest repateted items
+
+    Returns:
+        list[int]: the ids which are goning to be deleted if longest_repeat > len(seq) - target_len
+
+    Example:
+                seq = [1, 0, 1, 0, 0, 0, 0, 1], target_len = 7
+                                ^  ^  ^
+    Longest Repeat              ^  ^  ^
+    Ouput: [3]
+    """
+
+    if len(seq) <= target_len:
+        return []
+
+    longest_start = 0
+    longest_repeat = 0
+    curr_repeat = 1
+    curr_start = 0
+    for idx in range(len(seq) - 1):
+        curr = seq[idx]
+        next = seq[idx + 1]
+        if curr == next:
+            curr_repeat += 1
+        if (curr != next) or (idx == len(seq) - 2):
+            if curr_repeat > longest_repeat and curr_repeat >= min_repeat:
+                longest_repeat = curr_repeat
+                longest_start = curr_start
+            curr_start = idx + 1
+            curr_repeat = 1
+
+    # logical case to remote only from the longest repeat
+    if longest_repeat > len(seq) - target_len:
+        return list(range(longest_start, longest_start + len(seq) - target_len))
+    else:
+        return []

dependency_links.txt

@@ -0,0 +1 @@
+

entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+quran-muaalem-ui = quran_muaalem.gradio_app:main

explain.py

@@ -0,0 +1,250 @@
+from dataclasses import dataclass, asdict
+from typing import Literal
+import json
+
+from quran_transcript import SifaOutput
+import quran_transcript.alphabet as alph
+import diff_match_patch as dmp
+from rich import print
+from rich.text import Text
+from rich.table import Table
+from rich.console import Console
+
+from .muaalem_typing import Sifa
+from .modeling.vocab import SIFAT_ATTR_TO_ARABIC_WITHOUT_BRACKETS
+
+
+@dataclass
+class PhonemeGroup:
+    ref: str = ""
+    out: str = ""
+    ref_idx: int | None = None
+    out_idx: int | None = None
+    tag: Literal["exact", "partial", "insert", "delete"] | None = None
+
+    def get_tag(self):
+        if self.ref == "" and self.out == "":
+            raise ValueError("The Entire group is empty")
+        if self.ref == self.out:
+            self.tag = "exact"
+        elif self.ref != "" and self.out == "":
+            self.tag = "delete"
+        elif self.out != "" and self.ref == "":
+            self.tag = "insert"
+        else:
+            self.tag = "partial"
+        return self.tag
+
+
+def merge_same_phoneme_group(ph_groups: list[PhonemeGroup]) -> list[PhonemeGroup]:
+    outs = [ph_groups[0]]
+    prev_idx = 0
+    for curr_idx in range(1, len(ph_groups)):
+        # out is part of ref
+        if (
+            ph_groups[prev_idx].out_idx is not None
+            and ph_groups[curr_idx].ref_idx is not None
+            and ph_groups[prev_idx].out in ph_groups[curr_idx].ref
+        ):
+            del outs[-1]
+            outs.append(
+                PhonemeGroup(
+                    ref=ph_groups[curr_idx].ref,
+                    ref_idx=ph_groups[curr_idx].ref_idx,
+                    out=ph_groups[prev_idx].out,
+                    out_idx=ph_groups[prev_idx].out_idx,
+                )
+            )
+        # ref is part of out
+        elif (
+            ph_groups[prev_idx].ref_idx is not None
+            and ph_groups[curr_idx].out_idx is not None
+            and ph_groups[prev_idx].ref in ph_groups[curr_idx].out
+        ):
+            del outs[-1]
+            outs.append(
+                PhonemeGroup(
+                    ref=ph_groups[prev_idx].ref,
+                    ref_idx=ph_groups[prev_idx].ref_idx,
+                    out=ph_groups[curr_idx].out,
+                    out_idx=ph_groups[curr_idx].out_idx,
+                )
+            )
+        else:
+            outs.append(ph_groups[curr_idx])
+        prev_idx = curr_idx
+    return outs
+
+
+def segment_groups(
+    ref_groups: list[str],
+    groups: list[str],
+    diffs,
+) -> list[PhonemeGroup]:
+    """Join similar phonmes groups and diffrentiate between groups"""
+    ref_counter = 0
+    ref_ptr = 0
+    ref_group_idx = 0
+    out_counter = 0
+    out_ptr = 0
+    out_group_idx = 0
+
+    out_pairs = []
+    for op, data in diffs:
+        if op == 0:
+            ref_counter += len(data)
+            out_counter += len(data)
+        elif op == 1:
+            out_counter += len(data)
+        elif op == -1:
+            ref_counter += len(data)
+
+        ref_has_match = True
+        out_has_match = True
+        while ref_has_match or out_has_match:
+            pair = PhonemeGroup()
+            if ref_group_idx < len(ref_groups):
+                if (ref_counter - ref_ptr) >= len(ref_groups[ref_group_idx]):
+                    pair.ref = ref_groups[ref_group_idx]
+                    pair.ref_idx = ref_group_idx
+                    ref_ptr += len(ref_groups[ref_group_idx])
+                    ref_group_idx += 1
+                else:
+                    ref_has_match = False
+            else:
+                ref_has_match = False
+
+            if out_group_idx < len(groups):
+                if (out_counter - out_ptr) >= len(groups[out_group_idx]):
+                    pair.out = groups[out_group_idx]
+                    pair.out_idx = out_group_idx
+                    out_ptr += len(groups[out_group_idx])
+                    out_group_idx += 1
+                else:
+                    out_has_match = False
+            else:
+                out_has_match = False
+
+            if pair.ref or pair.out:
+                out_pairs.append(pair)
+    return merge_same_phoneme_group(out_pairs)
+
+
+def expalin_sifat(
+    sifat: list[Sifa],
+    exp_sifat: list[SifaOutput],
+    diffs,
+):
+    table = []
+    chunks = [s.phonemes_group for s in sifat]
+    exp_chunks = [s.phonemes for s in exp_sifat]
+
+    groups = segment_groups(ref_groups=exp_chunks, groups=chunks, diffs=diffs)
+    keys = set(asdict(sifat[0]).keys()) - {"phonemes_group"}
+    madd_group = alph.phonetics.alif + alph.phonetics.yaa_madd + alph.phonetics.waw_madd
+
+    for group in groups:
+        raw = {}
+        tag = group.get_tag()
+        if (tag == "exact") or (tag == "partial" and group.ref[0] in madd_group):
+            raw["tag"] = "exact"
+            raw["phonemes"] = sifat[group.out_idx].phonemes_group
+            raw["exp_phonemes"] = exp_sifat[group.ref_idx].phonemes
+            for key in keys:
+                if getattr(sifat[group.out_idx], key) is not None:
+                    raw[f"{key}"] = getattr(sifat[group.out_idx], key).text
+                else:
+                    raw[f"{key}"] = "None"
+
+                raw[f"exp_{key}"] = getattr(exp_sifat[group.ref_idx], key)
+        elif tag in {"partial", "insert"}:
+            raw["tag"] = "insert"
+            raw["phonemes"] = sifat[group.out_idx].phonemes_group
+            raw["exp_phonemes"] = ""
+            for key in keys:
+                if getattr(sifat[group.out_idx], key) is not None:
+                    raw[f"{key}"] = getattr(sifat[group.out_idx], key).text
+                else:
+                    raw[f"{key}"] = "None"
+
+                raw[f"exp_{key}"] = ""
+        if raw:
+            table.append(raw)
+
+    # print(json.dumps(table, indent=2, ensure_ascii=False))
+    return table
+
+
+def print_sifat_table(
+    table: list[dict],
+    lang: Literal["arabic", "english"] = "arabic",
+):
+    """Print the sifat comparison table with rich highlighting"""
+    if not table:
+        return
+
+    # Create a rich Table
+    rich_table = Table()
+
+    # Get base columns (non-exp keys without 'tag')
+    base_keys = [k for k in table[0].keys() if not k.startswith("exp_") and k != "tag"]
+
+    # Add columns
+    # rich_table.add_column("Tag", style="cyan")
+    for key in base_keys:
+        rich_table.add_column(key.replace("_", " ").title())
+
+    # Add rows
+    for row in table:
+        tag = row["tag"]
+        values = []
+        for key in base_keys:
+            exp_key = f"exp_{key}"
+            value = str(row[key])
+            if key != "phonemes" and lang == "arabic":
+                value = SIFAT_ATTR_TO_ARABIC_WITHOUT_BRACKETS[value]
+
+            # Apply styling based on tag and comparison
+            if tag == "exact" and row.get(exp_key) != row[key]:
+                values.append(f"[red]{value}[/red]")
+            elif tag == "insert":
+                values.append(f"[yellow]{value}[/yellow]")
+            else:
+                values.append(value)
+
+        rich_table.add_row(*values)
+
+    # Print the table
+    console = Console()
+    console.print(rich_table)
+
+
+def explain_for_terminal(
+    phonemes: str,
+    exp_phonemes: str,
+    sifat: list[Sifa],
+    exp_sifat: list[SifaOutput],
+    lang: Literal["arabic", "english"] = "english",
+):
+    # Create diff-match-patch object
+    dmp_obj = dmp.diff_match_patch()
+
+    # Calculate differences
+    diffs = dmp_obj.diff_main(exp_phonemes, phonemes)
+
+    # Create a Rich Text object for colored output
+    result = Text()
+
+    # Process each difference
+    for op, data in diffs:
+        if op == dmp_obj.DIFF_EQUAL:
+            result.append(data, style="white")
+        elif op == dmp_obj.DIFF_INSERT:
+            result.append(data, style="green")
+        elif op == dmp_obj.DIFF_DELETE:
+            result.append(data, style="red strike")
+
+    # Print the result
+    print(result)
+    sifat_table = expalin_sifat(sifat, exp_sifat, diffs)
+    print_sifat_table(sifat_table, lang=lang)  # Add this line to print the table

explain_gradio.py

@@ -0,0 +1,112 @@
+from typing import Literal
+import diff_match_patch as dmp
+
+from .explain import expalin_sifat
+from .modeling.vocab import SIFAT_ATTR_TO_ARABIC_WITHOUT_BRACKETS
+
+
+def explain_for_gradio(
+    phonemes: str,
+    exp_phonemes: str,
+    sifat: list,
+    exp_sifat: list,
+    lang: Literal["arabic", "english"] = "english",
+) -> str:
+    # Create diff-match-patch object
+    dmp_obj = dmp.diff_match_patch()
+
+    # Calculate differences using Google's diff-match-patch (same as terminal)
+    diffs = dmp_obj.diff_main(exp_phonemes, phonemes)
+
+    # Create HTML for phoneme differences
+    phoneme_html = explain_phonemes_html(dmp_obj, diffs)
+
+    # Create HTML for sifat table using your existing function
+    sifat_table = expalin_sifat(sifat, exp_sifat, diffs)
+    sifat_html = explain_sifat_html(sifat_table, lang)
+
+    # Combine both sections
+    html_output = f"""
+    <div style="font-family: monospace; width: 100%;">
+        <h3>مقارنة الحروف</h3>
+        {phoneme_html}
+        <h3>مقارنة صفات الحروف</h3>
+        {sifat_html}
+       <div class="color-legend">
+    </div>
+    """
+
+    return html_output
+
+
+def explain_phonemes_html(dmp_obj, diffs):
+    html_output = '<div style="background-color: #000; padding: 10px; border-radius: 5px; margin-bottom: 20px; font-size: 30px;">'
+
+    # Process each difference (same logic as terminal version)
+    for op, data in diffs:
+        if op == dmp_obj.DIFF_EQUAL:
+            html_output += f'<span style="color: #ffffff;">{data}</span>'
+        elif op == dmp_obj.DIFF_INSERT:
+            html_output += f'<span style="color: #00ff00;">{data}</span>'
+        elif op == dmp_obj.DIFF_DELETE:
+            html_output += f'<span style="color: #ff0000; text-decoration: line-through;">{data}</span>'
+
+    html_output += "</div>"
+    return html_output
+
+
+def explain_sifat_html(table, lang):
+    if not table:
+        return "<p>No sifat data available</p>"
+
+    # Create HTML table with full width
+    html_output = """
+    <table style="width: 100%; border-collapse: collapse; background-color: #000; color: #fff; margin-bottom: 20px;">
+        <thead>
+            <tr>
+    """
+
+    # Get base columns (non-exp keys without 'tag')
+    base_keys = [k for k in table[0].keys() if not k.startswith("exp_") and k != "tag"]
+
+    # Add columns
+    for key in base_keys:
+        html_output += f'<th style="border: 1px solid #444; padding: 8px; text-align: left;">{key.replace("_", " ").title()}</th>'
+
+    html_output += """
+            </tr>
+        </thead>
+        <tbody>
+    """
+
+    # Add rows
+    for row in table:
+        tag = row["tag"]
+        html_output += "<tr>"
+
+        for key in base_keys:
+            exp_key = f"exp_{key}"
+            value = str(row[key])
+
+            # Apply Arabic translation if needed
+            if key != "phonemes" and lang == "arabic":
+                value = SIFAT_ATTR_TO_ARABIC_WITHOUT_BRACKETS.get(value, value)
+
+            # Apply styling based on tag and comparison
+            if tag == "exact" and row.get(exp_key) != row[key]:
+                html_output += f'<td style="border: 1px solid #444; padding: 8px; color: #ff0000;">{value}</td>'
+            elif tag == "insert":
+                html_output += f'<td style="border: 1px solid #444; padding: 8px; color: #ffff00;">{value}</td>'
+            else:
+                html_output += (
+                    f'<td style="border: 1px solid #444; padding: 8px;">{value}</td>'
+                )
+
+        html_output += "</tr>"
+
+    html_output += """
+        </tbody>
+    </table>
+    """
+
+    return html_output

faq.md

@@ -0,0 +1,17 @@
+# FAQ
+
+## Why do I get a sampling rate error?
+
+`Muaalem.__call__` enforces `sampling_rate == 16000` in `src/quran_muaalem/inference.py`. Make sure your audio is resampled to 16 kHz.
+
+## The UI fails to load audio files
+
+Install system audio dependencies (see `README.md`):
+
+```bash
+sudo apt-get install -y ffmpeg libsndfile1 portaudio19-dev
+```
+
+## How do I change the model checkpoint?
+
+Pass `model_name_or_path` when constructing `Muaalem` or update `model_id` in `src/quran_muaalem/gradio_app.py`.

getting-started.md

@@ -0,0 +1,78 @@
+# Getting Started
+
+This project is a Python package with an optional Gradio UI. The core package lives in `src/quran_muaalem/` and depends on `quran-transcript` for phonetic reference generation.
+
+## Requirements
+
+From `README.md` and `pyproject.toml`:
+
+- Python 3.10+
+- System audio tools for common workflows:
+  - `ffmpeg` for audio decoding
+  - `libsndfile1` and `portaudio19-dev` if you work with audio I/O (see `README.md` install snippet)
+- Optional GPU (CUDA) for faster inference; the code uses `torch.cuda.is_available()` in `src/quran_muaalem/gradio_app.py`.
+
+## Install
+
+Core package:
+
+```bash
+pip install quran-muaalem
+```
+
+UI extras (adds Gradio + audio tooling):
+
+```bash
+pip install "quran-muaalem[ui]"
+```
+
+If you use `uv`, the README documents an all‑in‑one command for the UI:
+
+```bash
+uvx --no-cache --from https://github.com/obadx/quran-muaalem.git[ui] quran-muaalem-ui
+```
+
+## Quick Start (Python API)
+
+The main inference class is `Muaalem` in `src/quran_muaalem/inference.py`. It expects:
+
+- audio at **16 kHz** (`sampling_rate=16000` is enforced)
+- a reference phonetic script from `quran_transcript.quran_phonetizer`
+
+Minimal flow based on `README.md`:
+
+```python
+from librosa.core import load
+import torch
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+from quran_muaalem import Muaalem
+
+sampling_rate = 16000
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+uthmani_ref = Aya(8, 75).get_by_imlaey_words(17, 9).uthmani
+moshaf = MoshafAttributes(rewaya="hafs", madd_monfasel_len=2, madd_mottasel_len=4, madd_mottasel_waqf=4, madd_aared_len=2)
+ref = quran_phonetizer(uthmani_ref, moshaf, remove_spaces=True)
+
+muaalem = Muaalem(device=device)
+wave, _ = load("./assets/test.wav", sr=sampling_rate, mono=True)
+outs = muaalem([wave], [ref], sampling_rate=sampling_rate)
+```
+
+## Model download and cache
+
+The model is pulled from Hugging Face on first use. Cache locations are controlled by environment variables such as:
+
+- `HF_HOME`
+- `HUGGINGFACE_HUB_CACHE`
+- `TRANSFORMERS_CACHE`
+
+(see `Dockerfile` for example defaults).
+
+## Troubleshooting (common cases)
+
+- **`ValueError: sampling_rate has to be 16000`** → resample your audio to 16 kHz.
+- **Missing `ffmpeg`** → install it via your system package manager.
+- **Slow inference on CPU** → use GPU or shorten audio segments.
+
+For a full walkthrough, see the Quran Muaalem API page.

gradio-ui.md

@@ -0,0 +1,49 @@
+# واجهة Gradio
+
+مدخل الواجهة موجود في `src/quran_muaalem/gradio_app.py` ويُعرّف كسكربت طرفي باسم `quran-muaalem-ui` في `pyproject.toml`.
+
+## ماذا تفعل الواجهة؟
+
+أهم الدوال في `src/quran_muaalem/gradio_app.py`:
+
+- `process_audio(...)`
+  - تحميل الصوت عبر `librosa.load`.
+  - بناء مرجع صوتي عبر `quran_phonetizer`.
+  - تشغيل `Muaalem` وإرجاع HTML.
+- `update_uthmani_ref(...)`
+  - جلب نص الرسم العثماني عبر `quran_transcript.Aya`.
+- `create_gradio_input_for_field(...)`
+  - بناء عناصر الإدخال من `MoshafAttributes.model_fields`.
+
+## مسار الاستخدام في الواجهة
+
+1. اختيار **السورة** و **الآية**.
+2. تحديد **رقم الكلمة** و **عدد الكلمات**.
+3. رفع الصوت أو التسجيل.
+4. الضغط على زر التحليل لإظهار المقارنة.
+
+إذا كان مدى الكلمات يقطع كلمة عثمانية، ستظهر رسالة تحذير مرتبطة بـ `PartOfUthmaniWord`.
+
+## تشغيل الواجهة
+
+```python
+app.launch(server_name="0.0.0.0", share=True)
+```
+
+- لتعطيل المشاركة العامة: عدّل `share=False` في `main()`.
+- لتغيير المنفذ أو الواجهة: عدّل استدعاء `app.launch(...)`.
+
+## تشغيل الواجهة محليًا
+
+```bash
+pip install "quran-muaalem[ui]"
+quran-muaalem-ui
+```
+
+السكربت `quran-muaalem-ui` يشير إلى `quran_muaalem.gradio_app:main`.
+
+## قيود معروفة
+
+- الواجهة تعمل بأسلوب **غير متدفق** (تعالج الصوت كاملًا دفعة واحدة).
+- الأداء يعتمد على طول الصوت وتوفر GPU.
+- للمعالجة الدُفعية يُفضّل استخدام واجهة بايثون.

gradio_app.py

@@ -0,0 +1,401 @@
+import logging
+from dataclasses import asdict
+import json
+from typing import Literal, Optional, Any, get_origin, get_args
+
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+from quran_transcript.utils import PartOfUthmaniWord
+from quran_transcript.phonetics.moshaf_attributes import (
+    get_arabic_attributes,
+    get_arabic_name,
+)
+from librosa.core import load
+from pydantic.fields import FieldInfo, PydanticUndefined
+import torch
+import gradio as gr
+
+from quran_muaalem.inference import Muaalem
+from quran_muaalem.muaalem_typing import MuaalemOutput
+from quran_muaalem.explain import explain_for_terminal
+from quran_muaalem.explain_gradio import explain_for_gradio
+
+# Initialize components
+REQUIRED_MOSHAF_FIELDS = [
+    "rewaya",
+    "takbeer",
+    "madd_monfasel_len",
+    "madd_mottasel_len",
+    "madd_mottasel_waqf",
+    "madd_aared_len",
+    "madd_alleen_len",
+    "ghonna_lam_and_raa",
+    "meem_aal_imran",
+    "madd_yaa_alayn_alharfy",
+    "saken_before_hamz",
+    "sakt_iwaja",
+    "sakt_marqdena",
+    "sakt_man_raq",
+    "sakt_bal_ran",
+    "sakt_maleeyah",
+    "between_anfal_and_tawba",
+    "noon_and_yaseen",
+    "yaa_ataan",
+    "start_with_ism",
+    "yabsut",
+    "bastah",
+    "almusaytirun",
+    "bimusaytir",
+    "tasheel_or_madd",
+    "yalhath_dhalik",
+    "irkab_maana",
+    "noon_tamnna",
+    "harakat_daaf",
+    "alif_salasila",
+    "idgham_nakhluqkum",
+    "raa_firq",
+    "raa_alqitr",
+    "raa_misr",
+    "raa_nudhur",
+    "raa_yasr",
+    "meem_mokhfah",
+]
+model_id = "obadx/muaalem-model-v3_2"
+logging.basicConfig(level=logging.INFO)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+muaalem = Muaalem(model_name_or_path=model_id, device=device)
+sampling_rate = 16000
+
+# Load Sura information
+sura_idx_to_name = {}
+sura_to_aya_count = {}
+start_aya = Aya()
+for sura_idx in range(1, 115):
+    start_aya.set(sura_idx, 1)
+    sura_idx_to_name[sura_idx] = start_aya.get().sura_name
+    sura_to_aya_count[sura_idx] = start_aya.get().num_ayat_in_sura
+
+# Default moshaf settings
+default_moshaf = MoshafAttributes(
+    rewaya="hafs",
+    madd_monfasel_len=4,
+    madd_mottasel_len=4,
+    madd_mottasel_waqf=4,
+    madd_aared_len=4,
+)
+
+# Current moshaf settings (will be updated from settings page)
+current_moshaf = default_moshaf
+
+
+def get_field_name(field_name: str, field_info: FieldInfo) -> str:
+    """Return the Arabic name of the field if applicable else the field_name"""
+    label = field_name
+    arabic_name = get_arabic_name(field_info)
+    if arabic_name:
+        label = f"{arabic_name} ({field_name})"
+    return label
+
+
+def create_gradio_input_for_field(
+    field_name: str,
+    field_info: FieldInfo,
+    default_value: Any = None,
+    key_prefix="model_",
+    help: str | None = None,
+) -> Any:
+    """Create a gradio input field given a pydantic field info"""
+    # Extract Arabic name from field description if available
+    label = get_field_name(field_name, field_info)
+
+    if default_value is None:
+        if field_info.default != PydanticUndefined:
+            default_value = field_info.default
+
+    if help is None:
+        help = field_info.description
+
+    # Handle Literal types
+    if get_origin(field_info.annotation) is Literal:
+        choices = list(get_args(field_info.annotation))
+        arabic_attributes = get_arabic_attributes(field_info)
+
+        # Create choice list with Arabic labels if available
+        choice_list = []
+        for choice in choices:
+            if arabic_attributes and choice in arabic_attributes:
+                choice_list.append((arabic_attributes[choice], choice))
+            else:
+                choice_list.append((str(choice), choice))
+
+        return gr.Dropdown(
+            choices=choice_list,
+            value=default_value,
+            label=label,
+            info=help,
+            interactive=True,
+        )
+
+    # Handle different field types
+    if field_info.annotation in [str, Optional[str]]:
+        return gr.Textbox(value=default_value or "", label=label, info=help)
+    elif field_info.annotation in [int, Optional[int]]:
+        return gr.Number(value=default_value or 0, label=label, info=help, precision=0)
+    elif field_info.annotation in [float, Optional[float]]:
+        return gr.Number(
+            value=default_value or 0.0, label=label, info=help, precision=1
+        )
+    elif field_info.annotation in [bool, Optional[bool]]:
+        return gr.Checkbox(value=default_value or False, label=label, info=help)
+
+    raise ValueError(f"Unsupported field type for {label}: {field_info.annotation}")
+
+
+def update_aya_dropdown(sura_idx):
+    if not sura_idx:
+        sura_idx = 1
+    return gr.update(
+        choices=list(range(1, sura_to_aya_count[int(sura_idx)] + 1)), value=1
+    )
+
+
+def update_uthmani_ref(sura_idx, aya_idx, start_idx, num_words):
+    if not all([sura_idx, aya_idx, start_idx is not None, num_words is not None]):
+        return ""
+    try:
+        uthmani_ref = (
+            Aya(int(sura_idx), int(aya_idx))
+            .get_by_imlaey_words(int(start_idx), int(num_words))
+            .uthmani
+        )
+        return uthmani_ref
+    except PartOfUthmaniWord as e:
+        return f"⚠️ Warning: You've selected part of a Uthmani word. Please adjust the number of words to include complete words only.\n\nError details: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def process_audio(audio, sura_idx, aya_idx, start_idx, num_words):
+    global current_moshaf
+
+    if audio is None:
+        return "Please upload an audio file first"
+
+    try:
+        # Get Uthmani reference text
+        uthmani_ref = (
+            Aya(int(sura_idx), int(aya_idx))
+            .get_by_imlaey_words(int(start_idx), int(num_words))
+            .uthmani
+        )
+        phonetizer_out = quran_phonetizer(
+            uthmani_ref, current_moshaf, remove_spaces=True
+        )
+
+        # Process audio
+        wave, _ = load(audio, sr=sampling_rate, mono=True)
+        outs = muaalem(
+            [wave],
+            [phonetizer_out],
+            sampling_rate=sampling_rate,
+        )
+
+        # # Prepare output
+        # output_text = f"Phonemes: {outs[0].phonemes}\n\n"
+        # for sifa in outs[0].sifat:
+        #     output_text += json.dumps(asdict(sifa), indent=2, ensure_ascii=False) + "\n"
+        #     output_text += "*" * 30 + "\n"
+        # output_text += "-" * 40 + "\n\n"
+
+        # Add explanation
+        explanation_html = explain_for_gradio(
+            outs[0].phonemes.text,
+            phonetizer_out.phonemes,
+            outs[0].sifat,
+            phonetizer_out.sifat,
+            lang="arabic",
+        )
+
+        return explanation_html
+
+    except PartOfUthmaniWord as e:
+        return f"⚠️ Error: The selected word range includes partial Uthmani words. Please adjust the number of words to include complete words only.\n\nError details: {str(e)}"
+    # except Exception as e:
+    #     return f"Error processing audio: {str(e)}"
+
+
+def update_moshaf_settings(*args):
+    """Update the global moshaf settings with values from the settings page"""
+    global current_moshaf, field_names
+
+    try:
+        # Create a dictionary from the field names and values
+        settings_dict = dict(zip(field_names, args))
+
+        # Create a new MoshafAttributes object with the updated values
+        current_moshaf = MoshafAttributes(**settings_dict)
+        return "✅ تم حفظ الإعدادات بنجاح - Settings saved successfully!"
+    except Exception as e:
+        return f"❌ خطأ في حفظ الإعدادات - Error saving settings: {str(e)}"
+
+
+def reset_settings():
+    """Reset all settings to default values"""
+    global current_moshaf
+
+    try:
+        current_moshaf = default_moshaf
+        # Return default values for all fields
+        default_values = [
+            getattr(default_moshaf, field_name) for field_name in field_names
+        ]
+        return default_values + [
+            "✅ تم إعادة التعيين إلى الإعدادات الافتراضية - Reset to default settings successfully!"
+        ]
+    except Exception as e:
+        return [getattr(current_moshaf, field_name) for field_name in field_names] + [
+            f"❌ Error resetting settings: {str(e)}"
+        ]
+
+
+# Create the Gradio app
+with gr.Blocks(title="المعلم القرآني") as app:
+    # Store current moshaf settings in session state
+    current_moshaf_state = gr.State(default_moshaf)
+
+    # Initialize field names list
+    field_names = []
+
+    with gr.Tab("التحليل الرئيسي - Main Analysis"):
+        gr.Markdown("# كشف أخطاء التلاوة والتجويد وصفات الحروف")
+        gr.Markdown("اختر المقطع القرآني المراد تعلمه")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### التلاة المقارنة")
+
+                # Create sura dropdown with both index and name
+                sura_choices = [
+                    (f"{idx} - {sura_idx_to_name[idx]}", idx) for idx in range(1, 115)
+                ]
+                sura_dropdown = gr.Dropdown(
+                    choices=sura_choices,
+                    label="السورة",
+                    value=1,
+                    elem_id="sura_dropdown",
+                )
+
+                aya_dropdown = gr.Dropdown(
+                    choices=list(range(1, sura_to_aya_count[1] + 1)),
+                    label="رقم الآية",
+                    value=1,
+                    elem_id="aya_dropdown",
+                )
+                start_idx = gr.Number(
+                    value=0,
+                    label="رقمة الكلمة بداية من صفر (Word Index)",
+                    minimum=0,
+                    step=1,
+                    elem_id="start_idx",
+                )
+                num_words = gr.Number(
+                    value=4,
+                    label="عدد الكلمات",
+                    minimum=1,
+                    step=1,
+                    elem_id="num_words",
+                )
+                uthmani_text = gr.Textbox(
+                    label="الرسم العثماني",
+                    interactive=False,
+                    elem_id="uthmani_text",
+                )
+
+            with gr.Column(scale=2):
+                gr.Markdown("### فحص التلاوة القرآنية")
+                audio_input = gr.Audio(
+                    sources=["upload", "microphone"],
+                    label="Upload or Record Audio",
+                    type="filepath",
+                    elem_id="audio_input",
+                )
+                analyze_btn = gr.Button(
+                    "افحص التلاوة", variant="primary", elem_id="analyze_btn"
+                )
+                output_html = gr.HTML(
+                    label="نتيجة الفحص",
+                    elem_id="output_html",
+                )
+
+        # Initial update of uthmani text
+        app.load(
+            update_uthmani_ref,
+            inputs=[sura_dropdown, aya_dropdown, start_idx, num_words],
+            outputs=uthmani_text,
+        )
+
+        # Update aya dropdown when sura changes and reset aya_idx to 1
+        sura_dropdown.change(
+            update_aya_dropdown, inputs=sura_dropdown, outputs=aya_dropdown
+        ).then(
+            update_uthmani_ref,
+            inputs=[sura_dropdown, aya_dropdown, start_idx, num_words],
+            outputs=uthmani_text,
+        )
+
+        # Update uthmani text when any parameter changes
+        for component in [aya_dropdown, start_idx, num_words]:
+            component.change(
+                update_uthmani_ref,
+                inputs=[sura_dropdown, aya_dropdown, start_idx, num_words],
+                outputs=uthmani_text,
+            )
+
+        # Process audio when button is clicked
+        analyze_btn.click(
+            process_audio,
+            inputs=[audio_input, sura_dropdown, aya_dropdown, start_idx, num_words],
+            outputs=output_html,
+        )
+
+    with gr.Tab("إعدادات المصحف - Moshaf Settings"):
+        gr.Markdown("# إعدادات خصائص المصحف")
+        gr.Markdown("قم بتعديل خصائص المصحف حسب التلاوة المطلوبة")
+
+        # Create settings inputs directly in the tab
+        settings_components = []
+        fields = MoshafAttributes.model_fields
+
+        # Create inputs for all required fields
+        for field_name in REQUIRED_MOSHAF_FIELDS:
+            field_info = fields[field_name]
+            input_component = create_gradio_input_for_field(
+                field_name, field_info, getattr(default_moshaf, field_name, None)
+            )
+            settings_components.append(input_component)
+            field_names.append(field_name)
+
+        # Save button and status message
+        with gr.Row():
+            save_btn = gr.Button("حفظ الإعدادات - Save Settings", variant="primary")
+            reset_btn = gr.Button("إعادة التعيين - Reset to Default")
+
+        status_message = gr.Markdown()
+
+        # Save settings event
+        save_btn.click(
+            update_moshaf_settings, inputs=settings_components, outputs=status_message
+        )
+
+        # Reset to default event
+        reset_btn.click(
+            reset_settings, inputs=[], outputs=settings_components + [status_message]
+        )
+
+
+def main(app=app):
+    app.launch(server_name="0.0.0.0", share=True)
+
+
+if __name__ == "__main__":
+    main()
+    # app.launch(server_name="0.0.0.0", share=True)

index.md

@@ -0,0 +1,44 @@
+# نظرة عامة على المعلّم القرآني
+
+المعلّم القرآني هو طبقة الاستدلال التي **تقارن التلاوة بمرجع صوتي** وتنتج مخرجات متعددة المستويات: **فونيمات** + **صفات تجويدية** لكل مجموعة فونيمات.
+
+نقاط الدخول الأساسية:
+
+- الفئة `Muaalem` في `src/quran_muaalem/inference.py`.
+- واجهة Gradio في `src/quran_muaalem/gradio_app.py`.
+
+## لماذا هذا مهم للباحثين؟
+
+- النموذج لا يقوم بالنسخ فقط؛ بل ينتج **طبقة صفات** (سِفَات الحروف) قابلة للقياس والتحليل.
+- هذا يتيح دراسات مقارنة أدق من WER/PER التقليدي.
+
+## مسار الاستدلال الأساسي
+
+داخل `Muaalem.__call__`:
+
+1. ترميز المرجع الصوتي عبر `MultiLevelTokenizer`.
+2. استخراج خصائص الصوت عبر `AutoFeatureExtractor`.
+3. تشغيل نموذج `Wav2Vec2BertForMultilevelCTC`.
+4. فك الشيفرة عبر `phonemes_level_greedy_decode` و `multilevel_greedy_decode`.
+5. تجميع صفات كل مجموعة فونيمات في `Sifa` وإرجاع `MuaalemOutput`.
+
+> **ملاحظة:** المرجع الصوتي يُبنى باستخدام `quran_transcript.quran_phonetizer`.
+
+## القيود العملية
+
+- معدل العينة المطلوب: **16 kHz**.
+- جودة النتائج تعتمد على جودة المرجع (الرسم الصوتي) وجودة الصوت.
+- قيم الاحتمالات (`probs`) ليست مُعايرة افتراضيًا.
+
+## أين تجد التفاصيل؟
+
+- **واجهة بايثون**: شرح المدخلات والمخرجات والأمثلة.
+- **المخرجات**: مخطط تفصيلي للـ `MuaalemOutput`.
+- **المعمارية**: تفاصيل CTC متعدد المستويات.
+
+## ملفات أساسية
+
+- `src/quran_muaalem/inference.py` — فئة النموذج ومسار الاستدلال.
+- `src/quran_muaalem/decode.py` — فك الشيفرة والمحاذاة.
+- `src/quran_muaalem/muaalem_typing.py` — تعريف المخرجات.
+- `src/quran_muaalem/gradio_app.py` — واجهة المستخدم وإعدادات المصحف.

inference.py

@@ -0,0 +1,188 @@
+import logging
+
+from quran_transcript import chunck_phonemes, QuranPhoneticScriptOutput
+from transformers import AutoFeatureExtractor
+import torch
+from numpy.typing import NDArray
+
+from .modeling.multi_level_tokenizer import MultiLevelTokenizer
+from .modeling.modeling_multi_level_ctc import Wav2Vec2BertForMultilevelCTC
+from .decode import (
+    multilevel_greedy_decode,
+    phonemes_level_greedy_decode,
+)
+from .muaalem_typing import Unit, SingleUnit, Sifa, MuaalemOutput
+
+
+def format_sifat(
+    level_to_units: dict[str, list[Unit]],
+    chunked_phonemes_batch: list[list[str]],
+    multi_level_tokenizer: MultiLevelTokenizer,
+) -> list[list[Sifa]]:
+    sifat_batch = []
+    for seq_idx in range(len(chunked_phonemes_batch)):
+        sifat = []
+        for idx, ph_group in enumerate(chunked_phonemes_batch[seq_idx]):
+            sifa_dict = {}
+            for level in level_to_units:
+                if level == "phonemes":
+                    continue
+                sifa_idx = idx
+                if sifa_idx < len(level_to_units[level][seq_idx].ids):
+                    label = int(level_to_units[level][seq_idx].ids[sifa_idx])
+                    text = multi_level_tokenizer.sifat_to_en_vocab[level][label]
+                    p = level_to_units[level][seq_idx].probs[sifa_idx]
+                    sifa_dict[level] = SingleUnit(
+                        text=text, prob=float(p), idx=int(label)
+                    )
+                else:
+                    logging.info(
+                        f"Sequence: `{seq_idx}` has short Level: {level} we will place it with `None`"
+                    )
+                    sifa_dict[level] = None
+            sifat.append(
+                Sifa(
+                    phonemes_group=chunked_phonemes_batch[seq_idx][idx],
+                    **sifa_dict,
+                )
+            )
+        sifat_batch.append(sifat)
+    return sifat_batch
+
+
+class Muaalem:
+    def __init__(
+        self,
+        model_name_or_path: str = "obadx/muaalem-model-v3_2",
+        device: str = "cpu",
+        dtype=torch.bfloat16,
+    ):
+        """
+        Initializing Muallem Model
+
+        Args:
+            model_name_or_path: the huggingface model name or path
+            device: the device to run model on
+            dtype: the torch dtype. Default is `torch.bfloat16` as the model was trained on
+        """
+        self.device = device
+        self.dtype = dtype
+
+        self.model = Wav2Vec2BertForMultilevelCTC.from_pretrained(model_name_or_path)
+        self.multi_level_tokenizer = MultiLevelTokenizer(model_name_or_path)
+        self.processor = AutoFeatureExtractor.from_pretrained(model_name_or_path)
+
+        self.model.to(device, dtype=dtype)
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        waves: list[list[float] | torch.FloatTensor | NDArray],
+        ref_quran_phonetic_script_list: list[QuranPhoneticScriptOutput],
+        sampling_rate: int,
+    ) -> list[MuaalemOutput]:
+        """Infrence Funcion for the Quran Muaalem Project
+
+                waves: input waves  batch , seq_len with different formats described above
+                ref_quran_phonetic_script_list (list[QuranPhoneticScriptOutput]): list of the
+                    phonetized ouput of `quran_transcript.quran_phonetizer` with `remove_space=True`
+
+                sampleing_rate (int): has to be 16000
+
+        Returns:
+            list[MuaalemOutput]:
+                A list of output objects, each containing phoneme predictions and their
+                phonetic features (sifat) for a processed input.
+
+            Each MuaalemOutput contains:
+                phonemes (Unit):
+                    A dataclass representing the predicted phoneme sequence with:
+                        text (str): Concatenated string of all phonemes.
+                        probs (Union[torch.FloatTensor, list[float]]):
+                            Confidence probabilities for each predicted phoneme.
+                        ids (Union[torch.LongTensor, list[int]]):
+                            Token IDs corresponding to each phoneme.
+
+                sifat (list[Sifa]):
+                    A list of phonetic feature dataclasses (one per phoneme) with the
+                    following optional properties (each is a SingleUnit or None):
+                        - phonemes_group (str): the phonemes associated with the `sifa`
+                        - hams_or_jahr (SingleUnit): either `hams` or `jahr`
+                        - shidda_or_rakhawa (SingleUnit): either `shadeed`, `between`, or `rikhw`
+                        - tafkheem_or_taqeeq (SingleUnit): either `mofakham`, `moraqaq`, or `low_mofakham`
+                        - itbaq (SingleUnit): either `monfateh`, or `motbaq`
+                        - safeer (SingleUnit): either `safeer`, or `no_safeer`
+                        - qalqla (SingleUnit): eithr `moqalqal`, or `not_moqalqal`
+                        - tikraar (SingleUnit): either `mokarar` or `not_mokarar`
+                        - tafashie (SingleUnit): either `motafashie`, or `not_motafashie`
+                        - istitala (SingleUnit): either `mostateel`, or `not_mostateel`
+                        - ghonna (SingleUnit): either `maghnoon`, or `not_maghnoon`
+
+            Each SingleUnit in Sifa properties contains:
+                text (str): The feature's categorical label (e.g., "hams", "shidda").
+                prob (float): Confidence probability for this feature.
+                idx (int): Identifier for the feature class.
+        """
+
+        if sampling_rate != 16000:
+            raise ValueError(f"`sampling_rate` has to be 16000 got: `{sampling_rate}`")
+
+        # TODO: check input waves
+
+        # Tokanizing Ref
+        level_to_ref_ids = self.multi_level_tokenizer.tokenize(
+            [r.phonemes for r in ref_quran_phonetic_script_list],
+            [r.sifat for r in ref_quran_phonetic_script_list],
+            to_dict=True,
+            return_tensors="pt",
+            padding="longest",
+        )["input_ids"]
+
+        features = self.processor(
+            waves, sampling_rate=sampling_rate, return_tensors="pt"
+        )
+        features = {k: v.to(self.device, dtype=self.dtype) for k, v in features.items()}
+        outs = self.model(**features, return_dict=False)[0]
+
+        probs = {}
+        for level in outs:
+            probs[level] = (
+                torch.nn.functional.softmax(outs[level], dim=-1).cpu().to(torch.float32)
+            )
+
+        # Decoding only Phonemes Level
+        phonemes_units = phonemes_level_greedy_decode(
+            probs["phonemes"], self.multi_level_tokenizer.id_to_vocab["phonemes"]
+        )
+
+        chunked_phonemes_batch: list[list[str]] = []
+        for phonemes_unit in phonemes_units:
+            chunked_phonemes_batch.append(chunck_phonemes(phonemes_unit.text))
+
+        level_to_units = multilevel_greedy_decode(
+            level_to_probs=probs,
+            level_to_id_to_vocab=self.multi_level_tokenizer.id_to_vocab,
+            level_to_ref_ids=level_to_ref_ids,
+            chunked_phonemes_batch=chunked_phonemes_batch,
+            ref_chuncked_phonemes_batch=[
+                [s.phonemes for s in r.sifat] for r in ref_quran_phonetic_script_list
+            ],
+            phonemes_units=phonemes_units,
+        )
+
+        sifat_batch: list[list[Sifa]] = format_sifat(
+            level_to_units,
+            chunked_phonemes_batch,
+            self.multi_level_tokenizer,
+        )
+
+        outs = []
+        # looping over the batch
+        for idx in range(len(level_to_units["phonemes"])):
+            outs.append(
+                MuaalemOutput(
+                    phonemes=level_to_units["phonemes"][idx],
+                    sifat=sifat_batch[idx],
+                )
+            )
+        return outs

license.md

@@ -0,0 +1,5 @@
+# الترخيص
+
+المشروع مرخّص وفق رخصة MIT.
+
+راجع `LICENSE` في جذر المستودع للنص الكامل.

modeling_multi_level_ctc.py

@@ -0,0 +1,148 @@
+from typing import Optional, Union
+
+from transformers.models.wav2vec2_bert.modeling_wav2vec2_bert import (
+    Wav2Vec2BertPreTrainedModel,
+    Wav2Vec2BertModel,
+    _HIDDEN_STATES_START_POSITION,
+)
+from transformers.utils import auto_docstring
+from transformers.modeling_outputs import CausalLMOutput
+import torch
+from torch import nn
+
+from .configuration_multi_level_ctc import Wav2Vec2BertForMultilevelCTCConfig
+
+
+class Wav2Vec2BertForMultilevelCTC(Wav2Vec2BertPreTrainedModel):
+    config_class = Wav2Vec2BertForMultilevelCTCConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.wav2vec2_bert = Wav2Vec2BertModel(config)
+        self.dropout = nn.Dropout(config.final_dropout)
+
+        if config.level_to_vocab_size == {}:
+            raise ValueError(
+                f"You are trying to instantiate {self.__class__} with a configuration that "
+                "does not define the vocabulary size of the language model head. Please "
+                "instantiate the model as follows: `Wav2Vec2BertForCTC.from_pretrained(..., level_to_vocab_size=level_to_vocab_size)`. "
+                "or define `level_to_vocab_size` of your model's configuration."
+            )
+        output_hidden_size = (
+            config.output_hidden_size
+            if hasattr(config, "add_adapter") and config.add_adapter
+            else config.hidden_size
+        )
+        self.level_to_lm_head = nn.ModuleDict(
+            {
+                level: nn.Linear(output_hidden_size, vocab_size)
+                for level, vocab_size in config.level_to_vocab_size.items()
+            }
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @auto_docstring
+    def forward(
+        self,
+        input_features: Optional[torch.Tensor],
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        labels: Optional[dict[str, torch.Tensor]] = None,
+    ) -> Union[tuple, CausalLMOutput]:
+        r"""
+        labels (dict[`str`, `torch.LongTensor`] level_name to its labels of shape `(batch_size, target_length)`, *optional*):
+            Labels for connectionist temporal classification. Note that `target_length` has to be smaller or equal to
+            the sequence length of the output logits. Indices are selected in `[-100, 0, ..., config.vocab_size - 1]`.
+            All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ...,
+            config.vocab_size - 1]`.
+        """
+        if labels is not None:
+            if not isinstance(labels, dict):
+                raise ValueError(
+                    f"Label has to be a dict for level to its tartget labels got `{type(labels)}`"
+                )
+            for level in labels:
+                if labels[level].max() >= self.config.level_to_vocab_size[level]:
+                    raise ValueError(
+                        f"Label values must be <= vocab_size: {self.config.level_to_vocab_size[level]} for level: `{level}`"
+                    )
+
+        return_dict = (
+            return_dict if return_dict is not None else self.config.use_return_dict
+        )
+
+        outputs = self.wav2vec2_bert(
+            input_features,
+            attention_mask=attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = outputs[0]
+        hidden_states = self.dropout(hidden_states)
+
+        level_to_logits = {}
+        for level in self.level_to_lm_head:
+            level_to_logits[level] = self.level_to_lm_head[level](hidden_states)
+
+        loss = None
+        if labels is not None:
+            # retrieve loss input_lengths from attention_mask
+            attention_mask = (
+                attention_mask
+                if attention_mask is not None
+                else torch.ones(
+                    input_features.shape[:2],
+                    device=input_features.device,
+                    dtype=torch.long,
+                )
+            )
+            input_lengths = self._get_feat_extract_output_lengths(
+                attention_mask.sum([-1])
+            ).to(torch.long)
+
+            loss = 0.0
+            for level in labels:
+                # assuming that padded tokens are filled with -100
+                # when not being attended to
+                labels_mask = labels[level] >= 0
+                target_lengths = labels_mask.sum(-1)
+                flattened_targets = labels[level].masked_select(labels_mask)
+
+                # ctc_loss doesn't support fp16
+                log_probs = nn.functional.log_softmax(
+                    level_to_logits[level], dim=-1, dtype=torch.float32
+                ).transpose(0, 1)
+
+                with torch.backends.cudnn.flags(enabled=False):
+                    loss += self.config.level_to_loss_weight[
+                        level
+                    ] * nn.functional.ctc_loss(
+                        log_probs,
+                        flattened_targets,
+                        input_lengths,
+                        target_lengths,
+                        blank=self.config.pad_token_id,
+                        reduction=self.config.ctc_loss_reduction,
+                        zero_infinity=self.config.ctc_zero_infinity,
+                    )
+
+        if not return_dict:
+            output = (level_to_logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutput(
+            loss=loss,
+            logits=level_to_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+__all__ = ["Wav2Vec2BertForMultilevelCTC"]

muaalem_typing.py

@@ -0,0 +1,78 @@
+from dataclasses import dataclass
+import torch
+
+
+@dataclass
+class Unit:
+    """
+    probs: 1D tensors
+    """
+
+    text: str
+    probs: torch.FloatTensor | list[float]
+    ids: torch.LongTensor | list[int]
+
+
+@dataclass
+class SingleUnit:
+    """
+    A dataclass representing the predicted phoneme sequence with:
+        text (str): Concatenated string of all phonemes.
+        probs (Union[torch.FloatTensor, list[float]]):
+            Confidence probabilities for each predicted phoneme (1D tensor).
+        ids (Union[torch.LongTensor, list[int]]) (1D tensor):
+            Token IDs corresponding to each phoneme.
+
+    """
+
+    text: str
+    prob: float
+    idx: int
+
+
+@dataclass
+class Sifa:
+    """
+    following optional properties (each is a SingleUnit or None):
+        - phonemes_group (str): the phonemes associated with the `sifa`
+        - hams_or_jahr (SingleUnit): either `hams` or `jahr`
+        - shidda_or_rakhawa (SingleUnit): either `shadeed`, `between`, or `rikhw`
+        - tafkheem_or_taqeeq (SingleUnit): either `mofakham`, `moraqaq`, or `low_mofakham`
+        - itbaq (SingleUnit): either `monfateh`, or `motbaq`
+        - safeer (SingleUnit): either `safeer`, or `no_safeer`
+        - qalqla (SingleUnit): eithr `moqalqal`, or `not_moqalqal`
+        - tikraar (SingleUnit): either `mokarar` or `not_mokarar`
+        - tafashie (SingleUnit): either `motafashie`, or `not_motafashie`
+        - istitala (SingleUnit): either `mostateel`, or `not_mostateel`
+        - ghonna (SingleUnit): either `maghnoon`, or `not_maghnoon`
+
+    Each SingleUnit in Sifa properties contains:
+        text (str): The feature's categorical label (e.g., "hams", "shidda").
+        prob (float): Confidence probability for this feature.
+        idx (int): Identifier for the feature class.
+
+    """
+
+    phonemes_group: str
+    hams_or_jahr: SingleUnit | None
+    shidda_or_rakhawa: SingleUnit | None
+    tafkheem_or_taqeeq: SingleUnit | None
+    itbaq: SingleUnit | None
+    safeer: SingleUnit | None
+    qalqla: SingleUnit | None
+    tikraar: SingleUnit | None
+    tafashie: SingleUnit | None
+    istitala: SingleUnit | None
+    ghonna: SingleUnit | None
+
+
+@dataclass
+class MuaalemOutput:
+    """
+    text (str): The feature's categorical label (e.g., "hams", "shidda").
+    prob (float): Confidence probability for this feature.
+    idx (int): Identifier for the feature class.
+    """
+
+    phonemes: Unit
+    sifat: list[Sifa]

multi_level_tokenizer.py

@@ -0,0 +1,121 @@
+from typing import get_origin, Literal, Any
+
+from quran_transcript import SifaOutput, quran_phonetizer
+from transformers import Wav2Vec2CTCTokenizer
+
+from .vocab import PAD_TOKEN, PAD_TOKEN_IDX, SIFAT_ATTR_TO_ARABIC, SIFAT_ATTR_TO_ENGLISH
+
+
+def add_zero_between(L, x=PAD_TOKEN_IDX):
+    out = []
+    for i, item in enumerate(L):
+        out.append(item)
+        if i < len(L) - 1:  # Don't add zero after the last element
+            out.append(0)
+    return out
+
+
+class MultiLevelTokenizer:
+    def __init__(self, model_name_or_path: str):
+        self.levels = ["phonemes"]
+        for fieldname, fieldinfo in SifaOutput.model_fields.items():
+            if get_origin(fieldinfo.annotation) == Literal:
+                self.levels.append(fieldname)
+
+        self.level_to_tokenizer = {}
+        for level in self.levels:
+            self.level_to_tokenizer[level] = Wav2Vec2CTCTokenizer.from_pretrained(
+                model_name_or_path, pad_token=PAD_TOKEN, target_lang=level
+            )
+
+        self.level_to_id_vocab = self.get_level_to_id_to_voab()
+        self.sifat_level_to_id_to_en_vocab = self.get_sifat_levels_to_en_name()
+
+    def get_tokenizer(self):
+        return self.level_to_tokenizer["phonemes"]
+
+    @property
+    def vocab(self):
+        return self.get_tokenizer().vocab
+
+    @property
+    def id_to_vocab(self):
+        return self.level_to_id_vocab
+
+    @property
+    def sifat_to_en_vocab(self):
+        return self.sifat_level_to_id_to_en_vocab
+
+    def tokenize(
+        self,
+        phonetic_script: list[str] | str,
+        sifat: list[list[SifaOutput | dict]] | list[SifaOutput | dict],
+        to_dict=False,
+        **kwargs,
+    ) -> dict:
+        if isinstance(phonetic_script, str):
+            phonetic_script = [phonetic_script]
+        if not isinstance(sifat[0], list):
+            sifat = [sifat]
+
+        if isinstance(sifat[0][0], dict):
+            sifat = [[SifaOutput(**s) for s in inner_list] for inner_list in sifat]
+
+        level_to_text_list = {}
+        for level in self.levels:
+            if level == "phonemes":
+                text_list = phonetic_script
+            else:
+                text_list = [
+                    "".join(
+                        [SIFAT_ATTR_TO_ARABIC[getattr(s, level)] for s in inner_list]
+                    )
+                    for inner_list in sifat
+                ]
+            level_to_text_list[level] = text_list
+
+        level_to_tokenized = {}
+        for level in self.levels:
+            level_to_tokenized[level] = self.level_to_tokenizer[level](
+                level_to_text_list[level], **kwargs
+            )
+
+        if to_dict:
+            out_dict = {"input_ids": {}, "attention_mask": {}}
+            for level in level_to_tokenized:
+                for k in out_dict:
+                    out_dict[k][level] = level_to_tokenized[level][k]
+            return out_dict
+        return level_to_tokenized
+
+    def decode(
+        self, level_to_input_ids: dict[str, Any], place_zeros_in_between=False
+    ) -> dict[str, list[str] | str]:
+        level_to_decoded_outs = {}
+        for level in level_to_input_ids:
+            input_ids = level_to_input_ids[level]
+            if place_zeros_in_between:
+                input_ids = [add_zero_between(ids) for ids in input_ids]
+            level_to_decoded_outs[level] = self.level_to_tokenizer[level].batch_decode(
+                input_ids,
+            )
+        return level_to_decoded_outs
+
+    def get_level_to_id_to_voab(self):
+        vocab = self.get_tokenizer().vocab
+        level_to_ids_to_vocab = {}
+        for level in vocab:
+            level_to_ids_to_vocab[level] = {v: k for k, v in vocab[level].items()}
+        return level_to_ids_to_vocab
+
+    def get_sifat_levels_to_en_name(self):
+        level_to_id_to_vocab = self.get_level_to_id_to_voab()
+        level_to_id_to_en_vocab = {}
+        for level in level_to_id_to_vocab:
+            if level == "phonemes":
+                continue
+            level_to_id_to_en_vocab[level] = {
+                k: SIFAT_ATTR_TO_ENGLISH[v] if k != PAD_TOKEN_IDX else PAD_TOKEN
+                for k, v in level_to_id_to_vocab[level].items()
+            }
+        return level_to_id_to_en_vocab

output.md

@@ -0,0 +1,92 @@
+# المخرجات والشرح
+
+الاستدلال يُرجع قائمة من `MuaalemOutput` (`src/quran_muaalem/muaalem_typing.py`). كل عنصر يحتوي على:
+
+- `phonemes`: كائن `Unit` مع نص الفونيمات، الاحتمالات، والمعرّفات.
+- `sifat`: قائمة `Sifa` (عنصر لكل مجموعة فونيمات) مع خصائص اختيارية.
+
+## مخطط المخرجات (مفهومي)
+
+```text
+MuaalemOutput
+  phonemes: Unit
+  sifat: list[Sifa]
+
+Unit
+  text: str
+  probs: Tensor | list[float]
+  ids: Tensor | list[int]
+
+Sifa
+  phonemes_group: str
+  hams_or_jahr: SingleUnit | None
+  shidda_or_rakhawa: SingleUnit | None
+  tafkheem_or_taqeeq: SingleUnit | None
+  itbaq: SingleUnit | None
+  safeer: SingleUnit | None
+  qalqla: SingleUnit | None
+  tikraar: SingleUnit | None
+  tafashie: SingleUnit | None
+  istitala: SingleUnit | None
+  ghonna: SingleUnit | None
+
+SingleUnit
+  text: str
+  prob: float
+  idx: int
+```
+
+## مثال مبسّط
+
+```json
+{
+  "phonemes": {
+    "text": "بِسْمِٱللَّهِ...",
+    "probs": [0.98, 0.93, 0.87],
+    "ids": [12, 7, 31]
+  },
+  "sifat": [
+    {
+      "phonemes_group": "بِ",
+      "hams_or_jahr": {"text": "jahr", "prob": 0.99, "idx": 1},
+      "shidda_or_rakhawa": {"text": "shadeed", "prob": 0.95, "idx": 2},
+      "tafkheem_or_taqeeq": {"text": "moraqaq", "prob": 0.94, "idx": 1},
+      "itbaq": {"text": "monfateh", "prob": 0.92, "idx": 1},
+      "safeer": {"text": "no_safeer", "prob": 0.99, "idx": 0},
+      "qalqla": {"text": "not_moqalqal", "prob": 0.99, "idx": 0},
+      "tikraar": {"text": "not_mokarar", "prob": 0.99, "idx": 0},
+      "tafashie": {"text": "not_motafashie", "prob": 0.99, "idx": 0},
+      "istitala": {"text": "not_mostateel", "prob": 0.99, "idx": 0},
+      "ghonna": {"text": "not_maghnoon", "prob": 0.99, "idx": 0}
+    }
+  ]
+}
+```
+
+> ملاحظات:
+> - `probs` ناتجة عن softmax خاص بـ CTC وليست مُعايرة بالضرورة.
+> - قد تكون بعض حقول `Sifa` بقيمة `None` إذا حدث عدم تطابق في المحاذاة.
+
+## مقارنة التوقع مع المرجع
+
+هناك وحدتان لعرض النتائج:
+
+- `src/quran_muaalem/explain.py` يعرض جدولًا في الطرفية باستخدام `rich`.
+  - `explain_for_terminal(...)` يبني فرقًا بين الفونيمات المتوقعة والمرجع ثم يطبع جدولًا.
+- `src/quran_muaalem/explain_gradio.py` يولّد HTML لواجهة Gradio.
+  - `explain_for_gradio(...)` يعرض فرقًا ملونًا للفونيمات وجدول خصائص.
+
+كلاهما يستخدم `diff-match-patch` لتقسيم الإدراجات والحذف والاختلافات الجزئية بين الفونيمات.
+
+## حقول `Sifa`
+
+- `hams_or_jahr`
+- `shidda_or_rakhawa`
+- `tafkheem_or_taqeeq`
+- `itbaq`
+- `safeer`
+- `qalqla`
+- `tikraar`
+- `tafashie`
+- `istitala`
+- `ghonna`

package-lock.json

@@ -0,0 +1,2471 @@
+{
+  "name": "quran-muaalem-docs",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "quran-muaalem-docs",
+      "devDependencies": {
+        "vitepress": "^1.6.4"
+      }
+    },
+    "node_modules/@algolia/abtesting": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.12.2.tgz",
+      "integrity": "sha512-oWknd6wpfNrmRcH0vzed3UPX0i17o4kYLM5OMITyMVM2xLgaRbIafoxL0e8mcrNNb0iORCJA0evnNDKRYth5WQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/autocomplete-core": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz",
+      "integrity": "sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-plugin-algolia-insights": "1.17.7",
+        "@algolia/autocomplete-shared": "1.17.7"
+      }
+    },
+    "node_modules/@algolia/autocomplete-plugin-algolia-insights": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz",
+      "integrity": "sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-shared": "1.17.7"
+      },
+      "peerDependencies": {
+        "search-insights": ">= 1 < 3"
+      }
+    },
+    "node_modules/@algolia/autocomplete-preset-algolia": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz",
+      "integrity": "sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-shared": "1.17.7"
+      },
+      "peerDependencies": {
+        "@algolia/client-search": ">= 4.9.1 < 6",
+        "algoliasearch": ">= 4.9.1 < 6"
+      }
+    },
+    "node_modules/@algolia/autocomplete-shared": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz",
+      "integrity": "sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@algolia/client-search": ">= 4.9.1 < 6",
+        "algoliasearch": ">= 4.9.1 < 6"
+      }
+    },
+    "node_modules/@algolia/client-abtesting": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.46.2.tgz",
+      "integrity": "sha512-oRSUHbylGIuxrlzdPA8FPJuwrLLRavOhAmFGgdAvMcX47XsyM+IOGa9tc7/K5SPvBqn4nhppOCEz7BrzOPWc4A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-analytics": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.46.2.tgz",
+      "integrity": "sha512-EPBN2Oruw0maWOF4OgGPfioTvd+gmiNwx0HmD9IgmlS+l75DatcBkKOPNJN+0z3wBQWUO5oq602ATxIfmTQ8bA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-common": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.46.2.tgz",
+      "integrity": "sha512-Hj8gswSJNKZ0oyd0wWissqyasm+wTz1oIsv5ZmLarzOZAp3vFEda8bpDQ8PUhO+DfkbiLyVnAxsPe4cGzWtqkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-insights": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.46.2.tgz",
+      "integrity": "sha512-6dBZko2jt8FmQcHCbmNLB0kCV079Mx/DJcySTL3wirgDBUH7xhY1pOuUTLMiGkqM5D8moVZTvTdRKZUJRkrwBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-personalization": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.46.2.tgz",
+      "integrity": "sha512-1waE2Uqh/PHNeDXGn/PM/WrmYOBiUGSVxAWqiJIj73jqPqvfzZgzdakHscIVaDl6Cp+j5dwjsZ5LCgaUr6DtmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-query-suggestions": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.46.2.tgz",
+      "integrity": "sha512-EgOzTZkyDcNL6DV0V/24+oBJ+hKo0wNgyrOX/mePBM9bc9huHxIY2352sXmoZ648JXXY2x//V1kropF/Spx83w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-search": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.46.2.tgz",
+      "integrity": "sha512-ZsOJqu4HOG5BlvIFnMU0YKjQ9ZI6r3C31dg2jk5kMWPSdhJpYL9xa5hEe7aieE+707dXeMI4ej3diy6mXdZpgA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/ingestion": {
+      "version": "1.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.46.2.tgz",
+      "integrity": "sha512-1Uw2OslTWiOFDtt83y0bGiErJYy5MizadV0nHnOoHFWMoDqWW0kQoMFI65pXqRSkVvit5zjXSLik2xMiyQJDWQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/monitoring": {
+      "version": "1.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.46.2.tgz",
+      "integrity": "sha512-xk9f+DPtNcddWN6E7n1hyNNsATBCHIqAvVGG2EAGHJc4AFYL18uM/kMTiOKXE/LKDPyy1JhIerrh9oYb7RBrgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/recommend": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.46.2.tgz",
+      "integrity": "sha512-NApbTPj9LxGzNw4dYnZmj2BoXiAc8NmbbH6qBNzQgXklGklt/xldTvu+FACN6ltFsTzoNU6j2mWNlHQTKGC5+Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-browser-xhr": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.46.2.tgz",
+      "integrity": "sha512-ekotpCwpSp033DIIrsTpYlGUCF6momkgupRV/FA3m62SreTSZUKjgK6VTNyG7TtYfq9YFm/pnh65bATP/ZWJEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-fetch": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.46.2.tgz",
+      "integrity": "sha512-gKE+ZFi/6y7saTr34wS0SqYFDcjHW4Wminv8PDZEi0/mE99+hSrbKgJWxo2ztb5eqGirQTgIh1AMVacGGWM1iw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-node-http": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.46.2.tgz",
+      "integrity": "sha512-ciPihkletp7ttweJ8Zt+GukSVLp2ANJHU+9ttiSxsJZThXc4Y2yJ8HGVWesW5jN1zrsZsezN71KrMx/iZsOYpg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
+      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.5"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
+      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@docsearch/css": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz",
+      "integrity": "sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@docsearch/js": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/js/-/js-3.8.2.tgz",
+      "integrity": "sha512-Q5wY66qHn0SwA7Taa0aDbHiJvaFJLOJyHmooQ7y8hlwwQLQ/5WwCcoX0g7ii04Qi2DJlHsd0XXzJ8Ypw9+9YmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@docsearch/react": "3.8.2",
+        "preact": "^10.0.0"
+      }
+    },
+    "node_modules/@docsearch/react": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz",
+      "integrity": "sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-core": "1.17.7",
+        "@algolia/autocomplete-preset-algolia": "1.17.7",
+        "@docsearch/css": "3.8.2",
+        "algoliasearch": "^5.14.2"
+      },
+      "peerDependencies": {
+        "@types/react": ">= 16.8.0 < 19.0.0",
+        "react": ">= 16.8.0 < 19.0.0",
+        "react-dom": ">= 16.8.0 < 19.0.0",
+        "search-insights": ">= 1 < 3"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        },
+        "search-insights": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@iconify-json/simple-icons": {
+      "version": "1.2.63",
+      "resolved": "https://registry.npmjs.org/@iconify-json/simple-icons/-/simple-icons-1.2.63.tgz",
+      "integrity": "sha512-xZl2UWCwE58VlqZ+pDPmaUhE2tq8MVSTJRr4/9nzzHlDdjJ0Ud1VxNXPrwTSgESKY29iCQw3S0r2nJTSNNngHw==",
+      "dev": true,
+      "license": "CC0-1.0",
+      "dependencies": {
+        "@iconify/types": "*"
+      }
+    },
+    "node_modules/@iconify/types": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz",
+      "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.54.0.tgz",
+      "integrity": "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.54.0.tgz",
+      "integrity": "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.54.0.tgz",
+      "integrity": "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.54.0.tgz",
+      "integrity": "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.54.0.tgz",
+      "integrity": "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.54.0.tgz",
+      "integrity": "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.54.0.tgz",
+      "integrity": "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.54.0.tgz",
+      "integrity": "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.54.0.tgz",
+      "integrity": "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.54.0.tgz",
+      "integrity": "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.54.0.tgz",
+      "integrity": "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.54.0.tgz",
+      "integrity": "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.54.0.tgz",
+      "integrity": "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.54.0.tgz",
+      "integrity": "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.54.0.tgz",
+      "integrity": "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.54.0.tgz",
+      "integrity": "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.54.0.tgz",
+      "integrity": "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.54.0.tgz",
+      "integrity": "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.54.0.tgz",
+      "integrity": "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.54.0.tgz",
+      "integrity": "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.54.0.tgz",
+      "integrity": "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@shikijs/core": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-2.5.0.tgz",
+      "integrity": "sha512-uu/8RExTKtavlpH7XqnVYBrfBkUc20ngXiX9NSrBhOVZYv/7XQRKUyhtkeflY5QsxC0GbJThCerruZfsUaSldg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/engine-javascript": "2.5.0",
+        "@shikijs/engine-oniguruma": "2.5.0",
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4",
+        "hast-util-to-html": "^9.0.4"
+      }
+    },
+    "node_modules/@shikijs/engine-javascript": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-2.5.0.tgz",
+      "integrity": "sha512-VjnOpnQf8WuCEZtNUdjjwGUbtAVKuZkVQ/5cHy/tojVVRIRtlWMYVjyWhxOmIq05AlSOv72z7hRNRGVBgQOl0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "oniguruma-to-es": "^3.1.0"
+      }
+    },
+    "node_modules/@shikijs/engine-oniguruma": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-2.5.0.tgz",
+      "integrity": "sha512-pGd1wRATzbo/uatrCIILlAdFVKdxImWJGQ5rFiB5VZi2ve5xj3Ax9jny8QvkaV93btQEwR/rSz5ERFpC5mKNIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2"
+      }
+    },
+    "node_modules/@shikijs/langs": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-2.5.0.tgz",
+      "integrity": "sha512-Qfrrt5OsNH5R+5tJ/3uYBBZv3SuGmnRPejV9IlIbFH3HTGLDlkqgHymAlzklVmKBjAaVmkPkyikAV/sQ1wSL+w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/themes": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-2.5.0.tgz",
+      "integrity": "sha512-wGrk+R8tJnO0VMzmUExHR+QdSaPUl/NKs+a4cQQRWyoc3YFbUzuLEi/KWK1hj+8BfHRKm2jNhhJck1dfstJpiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/transformers": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-2.5.0.tgz",
+      "integrity": "sha512-SI494W5X60CaUwgi8u4q4m4s3YAFSxln3tzNjOSYqq54wlVgz0/NbbXEb3mdLbqMBztcmS7bVTaEd2w0qMmfeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/core": "2.5.0",
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/types": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-2.5.0.tgz",
+      "integrity": "sha512-ygl5yhxki9ZLNuNpPitBWvcy9fsSKKaRuO4BAlMyagszQidxcpLAr0qiW/q43DtSIDxO6hEbtYLiFZNXO/hdGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      }
+    },
+    "node_modules/@shikijs/vscode-textmate": {
+      "version": "10.0.2",
+      "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz",
+      "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/markdown-it": {
+      "version": "14.1.2",
+      "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz",
+      "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/linkify-it": "^5",
+        "@types/mdurl": "^2"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/web-bluetooth": {
+      "version": "0.0.21",
+      "resolved": "https://registry.npmjs.org/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz",
+      "integrity": "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.26.tgz",
+      "integrity": "sha512-vXyI5GMfuoBCnv5ucIT7jhHKl55Y477yxP6fc4eUswjP8FG3FFVFd41eNDArR+Uk3QKn2Z85NavjaxLxOC19/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.5",
+        "@vue/shared": "3.5.26",
+        "entities": "^7.0.0",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.26.tgz",
+      "integrity": "sha512-y1Tcd3eXs834QjswshSilCBnKGeQjQXB6PqFn/1nxcQw4pmG42G8lwz+FZPAZAby6gZeHSt/8LMPfZ4Rb+Bd/A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.26",
+        "@vue/shared": "3.5.26"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.26.tgz",
+      "integrity": "sha512-egp69qDTSEZcf4bGOSsprUr4xI73wfrY5oRs6GSgXFTiHrWj4Y3X5Ydtip9QMqiCMCPVwLglB9GBxXtTadJ3mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.5",
+        "@vue/compiler-core": "3.5.26",
+        "@vue/compiler-dom": "3.5.26",
+        "@vue/compiler-ssr": "3.5.26",
+        "@vue/shared": "3.5.26",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.21",
+        "postcss": "^8.5.6",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.26.tgz",
+      "integrity": "sha512-lZT9/Y0nSIRUPVvapFJEVDbEXruZh2IYHMk2zTtEgJSlP5gVOqeWXH54xDKAaFS4rTnDeDBQUYDtxKyoW9FwDw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.26",
+        "@vue/shared": "3.5.26"
+      }
+    },
+    "node_modules/@vue/devtools-api": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.9.tgz",
+      "integrity": "sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-kit": "^7.7.9"
+      }
+    },
+    "node_modules/@vue/devtools-kit": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.9.tgz",
+      "integrity": "sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-shared": "^7.7.9",
+        "birpc": "^2.3.0",
+        "hookable": "^5.5.3",
+        "mitt": "^3.0.1",
+        "perfect-debounce": "^1.0.0",
+        "speakingurl": "^14.0.1",
+        "superjson": "^2.2.2"
+      }
+    },
+    "node_modules/@vue/devtools-shared": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.9.tgz",
+      "integrity": "sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "rfdc": "^1.4.1"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.26.tgz",
+      "integrity": "sha512-9EnYB1/DIiUYYnzlnUBgwU32NNvLp/nhxLXeWRhHUEeWNTn1ECxX8aGO7RTXeX6PPcxe3LLuNBFoJbV4QZ+CFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.26"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.26.tgz",
+      "integrity": "sha512-xJWM9KH1kd201w5DvMDOwDHYhrdPTrAatn56oB/LRG4plEQeZRQLw0Bpwih9KYoqmzaxF0OKSn6swzYi84e1/Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.26",
+        "@vue/shared": "3.5.26"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.26.tgz",
+      "integrity": "sha512-XLLd/+4sPC2ZkN/6+V4O4gjJu6kSDbHAChvsyWgm1oGbdSO3efvGYnm25yCjtFm/K7rrSDvSfPDgN1pHgS4VNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.26",
+        "@vue/runtime-core": "3.5.26",
+        "@vue/shared": "3.5.26",
+        "csstype": "^3.2.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.26.tgz",
+      "integrity": "sha512-TYKLXmrwWKSodyVuO1WAubucd+1XlLg4set0YoV+Hu8Lo79mp/YMwWV5mC5FgtsDxX3qo1ONrxFaTP1OQgy1uA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.26",
+        "@vue/shared": "3.5.26"
+      },
+      "peerDependencies": {
+        "vue": "3.5.26"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.26.tgz",
+      "integrity": "sha512-7Z6/y3uFI5PRoKeorTOSXKcDj0MSasfNNltcslbFrPpcw6aXRUALq4IfJlaTRspiWIUOEZbrpM+iQGmCOiWe4A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vueuse/core": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/core/-/core-12.8.2.tgz",
+      "integrity": "sha512-HbvCmZdzAu3VGi/pWYm5Ut+Kd9mn1ZHnn4L5G8kOQTPs/IwIAmJoBrmYk2ckLArgMXZj0AW3n5CAejLUO+PhdQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/web-bluetooth": "^0.0.21",
+        "@vueuse/metadata": "12.8.2",
+        "@vueuse/shared": "12.8.2",
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/@vueuse/integrations": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/integrations/-/integrations-12.8.2.tgz",
+      "integrity": "sha512-fbGYivgK5uBTRt7p5F3zy6VrETlV9RtZjBqd1/HxGdjdckBgBM4ugP8LHpjolqTj14TXTxSK1ZfgPbHYyGuH7g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vueuse/core": "12.8.2",
+        "@vueuse/shared": "12.8.2",
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "async-validator": "^4",
+        "axios": "^1",
+        "change-case": "^5",
+        "drauu": "^0.4",
+        "focus-trap": "^7",
+        "fuse.js": "^7",
+        "idb-keyval": "^6",
+        "jwt-decode": "^4",
+        "nprogress": "^0.2",
+        "qrcode": "^1.5",
+        "sortablejs": "^1",
+        "universal-cookie": "^7"
+      },
+      "peerDependenciesMeta": {
+        "async-validator": {
+          "optional": true
+        },
+        "axios": {
+          "optional": true
+        },
+        "change-case": {
+          "optional": true
+        },
+        "drauu": {
+          "optional": true
+        },
+        "focus-trap": {
+          "optional": true
+        },
+        "fuse.js": {
+          "optional": true
+        },
+        "idb-keyval": {
+          "optional": true
+        },
+        "jwt-decode": {
+          "optional": true
+        },
+        "nprogress": {
+          "optional": true
+        },
+        "qrcode": {
+          "optional": true
+        },
+        "sortablejs": {
+          "optional": true
+        },
+        "universal-cookie": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vueuse/metadata": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/metadata/-/metadata-12.8.2.tgz",
+      "integrity": "sha512-rAyLGEuoBJ/Il5AmFHiziCPdQzRt88VxR+Y/A/QhJ1EWtWqPBBAxTAFaSkviwEuOEZNtW8pvkPgoCZQ+HxqW1A==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/@vueuse/shared": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/shared/-/shared-12.8.2.tgz",
+      "integrity": "sha512-dznP38YzxZoNloI0qpEfpkms8knDtaoQ6Y/sfS0L7Yki4zh40LFHEhur0odJC6xTHG5dxWVPiUWBXn+wCG2s5w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/algoliasearch": {
+      "version": "5.46.2",
+      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.46.2.tgz",
+      "integrity": "sha512-qqAXW9QvKf2tTyhpDA4qXv1IfBwD2eduSW6tUEBFIfCeE9gn9HQ9I5+MaKoenRuHrzk5sQoNh1/iof8mY7uD6Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@algolia/abtesting": "1.12.2",
+        "@algolia/client-abtesting": "5.46.2",
+        "@algolia/client-analytics": "5.46.2",
+        "@algolia/client-common": "5.46.2",
+        "@algolia/client-insights": "5.46.2",
+        "@algolia/client-personalization": "5.46.2",
+        "@algolia/client-query-suggestions": "5.46.2",
+        "@algolia/client-search": "5.46.2",
+        "@algolia/ingestion": "1.46.2",
+        "@algolia/monitoring": "1.46.2",
+        "@algolia/recommend": "5.46.2",
+        "@algolia/requester-browser-xhr": "5.46.2",
+        "@algolia/requester-fetch": "5.46.2",
+        "@algolia/requester-node-http": "5.46.2"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/birpc": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.9.0.tgz",
+      "integrity": "sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/copy-anything": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-4.0.5.tgz",
+      "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-what": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/emoji-regex-xs": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex-xs/-/emoji-regex-xs-1.0.0.tgz",
+      "integrity": "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/entities": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.0.tgz",
+      "integrity": "sha512-FDWG5cmEYf2Z00IkYRhbFrwIwvdFKH07uV8dvNy0omp/Qb1xcyCWp2UDtcwJF4QZZvk0sLudP6/hAu42TaqVhQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/focus-trap": {
+      "version": "7.7.0",
+      "resolved": "https://registry.npmjs.org/focus-trap/-/focus-trap-7.7.0.tgz",
+      "integrity": "sha512-DJJDHpEgoSbP8ZE1MNeU2IzCpfFyFdNZZRilqmfH2XiQsPK6PtD8AfJqWzEBudUQB2yHwZc5iq54rjTaGQ+ljw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tabbable": "^6.3.0"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/hast-util-to-html": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz",
+      "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "html-void-elements": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "stringify-entities": "^4.0.0",
+        "zwitch": "^2.0.4"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hookable": {
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz",
+      "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/html-void-elements": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
+      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-what": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz",
+      "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/mark.js": {
+      "version": "8.11.1",
+      "resolved": "https://registry.npmjs.org/mark.js/-/mark.js-8.11.1.tgz",
+      "integrity": "sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/minisearch": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/minisearch/-/minisearch-7.2.0.tgz",
+      "integrity": "sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/oniguruma-to-es": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-3.1.1.tgz",
+      "integrity": "sha512-bUH8SDvPkH3ho3dvwJwfonjlQ4R80vjyvrU8YpxuROddv55vAEJrTuCuCVUhhsHbtlD9tGGbaNApGQckXhS8iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex-xs": "^1.0.0",
+        "regex": "^6.0.1",
+        "regex-recursion": "^6.0.2"
+      }
+    },
+    "node_modules/perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/preact": {
+      "version": "10.28.1",
+      "resolved": "https://registry.npmjs.org/preact/-/preact-10.28.1.tgz",
+      "integrity": "sha512-u1/ixq/lVQI0CakKNvLDEcW5zfCjUQfZdK9qqWuIJtsezuyG6pk9TWj75GMuI/EzRSZB/VAE43sNWWZfiy8psw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/preact"
+      }
+    },
+    "node_modules/property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz",
+      "integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-recursion": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz",
+      "integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-utilities": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz",
+      "integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/rfdc": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/rollup": {
+      "version": "4.54.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.54.0.tgz",
+      "integrity": "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.54.0",
+        "@rollup/rollup-android-arm64": "4.54.0",
+        "@rollup/rollup-darwin-arm64": "4.54.0",
+        "@rollup/rollup-darwin-x64": "4.54.0",
+        "@rollup/rollup-freebsd-arm64": "4.54.0",
+        "@rollup/rollup-freebsd-x64": "4.54.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.54.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.54.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.54.0",
+        "@rollup/rollup-linux-arm64-musl": "4.54.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.54.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.54.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.54.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-gnu": "4.54.0",
+        "@rollup/rollup-linux-x64-musl": "4.54.0",
+        "@rollup/rollup-openharmony-arm64": "4.54.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.54.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.54.0",
+        "@rollup/rollup-win32-x64-gnu": "4.54.0",
+        "@rollup/rollup-win32-x64-msvc": "4.54.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/search-insights": {
+      "version": "2.17.3",
+      "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz",
+      "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/shiki": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/shiki/-/shiki-2.5.0.tgz",
+      "integrity": "sha512-mI//trrsaiCIPsja5CNfsyNOqgAZUb6VpJA+340toL42UpzQlXpwRV9nch69X6gaUxrr9kaOOa6e3y3uAkGFxQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/core": "2.5.0",
+        "@shikijs/engine-javascript": "2.5.0",
+        "@shikijs/engine-oniguruma": "2.5.0",
+        "@shikijs/langs": "2.5.0",
+        "@shikijs/themes": "2.5.0",
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/speakingurl": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz",
+      "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/superjson": {
+      "version": "2.2.6",
+      "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.6.tgz",
+      "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "copy-anything": "^4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tabbable": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.3.0.tgz",
+      "integrity": "sha512-EIHvdY5bPLuWForiR/AN2Bxngzpuwn1is4asboytXtpTgsArc+WmSJKVLlhdh71u7jFcryDqB2A8lQvj78MkyQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitepress": {
+      "version": "1.6.4",
+      "resolved": "https://registry.npmjs.org/vitepress/-/vitepress-1.6.4.tgz",
+      "integrity": "sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@docsearch/css": "3.8.2",
+        "@docsearch/js": "3.8.2",
+        "@iconify-json/simple-icons": "^1.2.21",
+        "@shikijs/core": "^2.1.0",
+        "@shikijs/transformers": "^2.1.0",
+        "@shikijs/types": "^2.1.0",
+        "@types/markdown-it": "^14.1.2",
+        "@vitejs/plugin-vue": "^5.2.1",
+        "@vue/devtools-api": "^7.7.0",
+        "@vue/shared": "^3.5.13",
+        "@vueuse/core": "^12.4.0",
+        "@vueuse/integrations": "^12.4.0",
+        "focus-trap": "^7.6.4",
+        "mark.js": "8.11.1",
+        "minisearch": "^7.1.1",
+        "shiki": "^2.1.0",
+        "vite": "^5.4.14",
+        "vue": "^3.5.13"
+      },
+      "bin": {
+        "vitepress": "bin/vitepress.js"
+      },
+      "peerDependencies": {
+        "markdown-it-mathjax3": "^4",
+        "postcss": "^8"
+      },
+      "peerDependenciesMeta": {
+        "markdown-it-mathjax3": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue": {
+      "version": "3.5.26",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.26.tgz",
+      "integrity": "sha512-SJ/NTccVyAoNUJmkM9KUqPcYlY+u8OVL1X5EW9RIs3ch5H2uERxyyIUI4MRxVCSOiEcupX9xNGde1tL9ZKpimA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.26",
+        "@vue/compiler-sfc": "3.5.26",
+        "@vue/runtime-dom": "3.5.26",
+        "@vue/server-renderer": "3.5.26",
+        "@vue/shared": "3.5.26"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,13 @@
+{
+  "name": "quran-muaalem-docs",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "docs:dev": "vitepress dev .",
+    "docs:build": "vitepress build .",
+    "docs:preview": "vitepress preview ."
+  },
+  "devDependencies": {
+    "vitepress": "^1.6.4"
+  }
+}

paper.md

@@ -0,0 +1,9 @@
+# الورقة العلمية
+
+الورقة المذكورة في `README.md` متاحة على arXiv:
+
+- https://arxiv.org/abs/2509.00094
+
+نسخة PDF من هذا المستودع متاحة هنا:
+
+- /paper.pdf

paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63f5a74293896b30e2089e725b085aad40560cafc696f3701411e2ea64403b8d
+size 498941

pyproject.toml

@@ -0,0 +1,60 @@
+# main docs of setup tools: https://setuptools.pypa.io/en/latest/userguide/quickstart.html
+# pypip tutoral: https://packaging.python.org/en/latest/tutorials/packaging-projects/
+# Video Tutorial: https://www.youtube.com/watch?v=v6tALyc4C10
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+license = "MIT"
+name = "quran-muaalem"
+version = "0.0.3"
+authors = [
+  { name="Abdullah", email="abdullahamlyossef@gmail.com" },
+]
+description = "Quran Phonetic Script with addional quarnic utils"
+readme = "README.md"
+dependencies = [
+    "diff-match-patch>=20241021",
+    "numpy>=2.2.6",
+    "quran-transcript>=0.1.0",
+    "rich>=14.1.0",
+    "torch>=2.7.0",
+    "transformers>=4.55.0",
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+
+
+# Optional dependencies
+[project.optional-dependencies]
+
+test = [
+  "librosa>=0.11.0",
+  "numba>=0.61.2",
+  "pytest",
+]
+ui = [
+    "gradio>=5.43.1",
+    "librosa>=0.11.0",
+    "numba>=0.61.2",
+    "moviepy>=2.2.1",
+]
+
+
+[project.scripts]
+quran-muaalem-ui = "quran_muaalem.gradio_app:main"
+
+[project.urls]
+Homepage = "https://github.com/obadx/quran-muaalem"
+Issues = "https://github.com/obadx/quran-muaalem/issues"
+
+# for addint data: https://setuptools.pypa.io/en/latest/userguide/datafiles.html#package-data
+# [tool.setuptools.package-data]
+# quran_transcript = ["quran-script/*"]

python-api.md

@@ -0,0 +1,102 @@
+# واجهة بايثون
+
+الفئة الأساسية للاستدلال هي `Muaalem` في `src/quran_muaalem/inference.py`. هذه الفئة تشغّل نموذج CTC متعدد المستويات وتعيد نواتج الفونيمات وصفات الحروف.
+
+## توقيع الفئة
+
+```python
+class Muaalem:
+    def __init__(
+        self,
+        model_name_or_path: str = "obadx/muaalem-model-v3_2",
+        device: str = "cpu",
+        dtype=torch.bfloat16,
+    ):
+        ...
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        waves: list[list[float] | torch.FloatTensor | NDArray],
+        ref_quran_phonetic_script_list: list[QuranPhoneticScriptOutput],
+        sampling_rate: int,
+    ) -> list[MuaalemOutput]:
+        ...
+```
+
+## المدخلات
+
+### 1) الصوت (`waves`)
+- قائمة من الموجات (batch).
+- كل موجة يمكن أن تكون:
+  - `list[float]`
+  - `torch.FloatTensor`
+  - `numpy.ndarray`
+- **معدل العينة المطلوب:** `16000 Hz`. التنفيذ يرفع `ValueError` إن لم يكن كذلك.
+
+### 2) المرجع الصوتي (`ref_quran_phonetic_script_list`)
+- قائمة من كائنات `QuranPhoneticScriptOutput`.
+- يتم توليدها عبر `quran_transcript.quran_phonetizer(..., remove_spaces=True)` لضمان تطابق المحاذاة.
+
+مثال توليد المرجع:
+
+```python
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+
+uthmani_ref = Aya(8, 75).get_by_imlaey_words(17, 9).uthmani
+moshaf = MoshafAttributes(
+    rewaya="hafs",
+    madd_monfasel_len=4,
+    madd_mottasel_len=4,
+    madd_mottasel_waqf=4,
+    madd_aared_len=4,
+)
+ref = quran_phonetizer(uthmani_ref, moshaf, remove_spaces=True)
+```
+
+## المخرجات
+
+الإرجاع يكون `list[MuaalemOutput]` (عنصر لكل موجة). راجع `src/quran_muaalem/muaalem_typing.py`:
+
+- `Unit`: تسلسل مفكوك مع `text` و `probs` و `ids`.
+- `Sifa`: خصائص لكل مجموعة فونيمات (قيمة `SingleUnit` أو `None`).
+- `MuaalemOutput`: حاوية تضم `phonemes` و `sifat`.
+
+للتفاصيل والمثال العملي راجع صفحة **المخرجات**.
+
+## مثال سريع
+
+```python
+from librosa.core import load
+import torch
+from quran_transcript import Aya, quran_phonetizer, MoshafAttributes
+from quran_muaalem import Muaalem
+
+sampling_rate = 16000
+wave, _ = load("./assets/test.wav", sr=sampling_rate, mono=True)
+
+uthmani_ref = Aya(8, 75).get_by_imlaey_words(17, 9).uthmani
+moshaf = MoshafAttributes(
+    rewaya="hafs",
+    madd_monfasel_len=4,
+    madd_mottasel_len=4,
+    madd_mottasel_waqf=4,
+    madd_aared_len=4,
+)
+ref = quran_phonetizer(uthmani_ref, moshaf, remove_spaces=True)
+
+model = Muaalem(device="cuda" if torch.cuda.is_available() else "cpu")
+outs = model([wave], [ref], sampling_rate=sampling_rate)
+print(outs[0].phonemes.text)
+```
+
+## ملاحظات عن الأخطاء والحالات الطرفية
+
+- إذا كان `sampling_rate` لا يساوي 16000 يتم رفع `ValueError`.
+- عند اختلاف أطوال المحاذاة قد تُضاف رموز حشو، وقد تكون بعض صفات `Sifa` بقيمة `None`.
+- النموذج يعمل دائمًا في وضع الاستدلال (`torch.no_grad()`).
+
+## الأداء
+
+- القيمة الافتراضية لـ `dtype` هي `torch.bfloat16`. يمكن تغييرها إلى `torch.float16` إذا كانت بطاقة الرسوم لا تدعم BF16.
+- يفضل إعادة استخدام نفس كائن `Muaalem` لتجنب تكلفة إعادة تحميل النموذج.

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+opencv-python
+numpy
+mediapipe

requires.txt

@@ -0,0 +1,17 @@
+diff-match-patch>=20241021
+numpy>=2.2.6
+quran-transcript>=0.1.0
+rich>=14.1.0
+torch>=2.7.0
+transformers>=4.55.0
+
+[test]
+librosa>=0.11.0
+numba>=0.61.2
+pytest
+
+[ui]
+gradio>=5.43.1
+librosa>=0.11.0
+numba>=0.61.2
+moviepy>=2.2.1

test.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3a827103e67142ad69be1722f513e6400d38624aa96c2706da2025674726c24
+size 16909